@finbourne/lusid-sdk-angular18/lib/.generated/api/conventions.service.d.ts

An Angular (18) SDK for secure access to the LUSID® by FINBOURNE web API

import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
import { Observable } from 'rxjs';
import { AnnulSingleStructuredDataResponse } from '../model/annulSingleStructuredDataResponse';
import { GetCdsFlowConventionsResponse } from '../model/getCdsFlowConventionsResponse';
import { GetFlowConventionsResponse } from '../model/getFlowConventionsResponse';
import { GetIndexConventionResponse } from '../model/getIndexConventionResponse';
import { ResourceListOfGetCdsFlowConventionsResponse } from '../model/resourceListOfGetCdsFlowConventionsResponse';
import { ResourceListOfGetFlowConventionsResponse } from '../model/resourceListOfGetFlowConventionsResponse';
import { ResourceListOfGetIndexConventionResponse } from '../model/resourceListOfGetIndexConventionResponse';
import { UpsertCdsFlowConventionsRequest } from '../model/upsertCdsFlowConventionsRequest';
import { UpsertFlowConventionsRequest } from '../model/upsertFlowConventionsRequest';
import { UpsertIndexConventionRequest } from '../model/upsertIndexConventionRequest';
import { UpsertSingleStructuredDataResponse } from '../model/upsertSingleStructuredDataResponse';
import { Configuration } from '../configuration';
import * as i0 from "@angular/core";
export interface DeleteCdsFlowConventionsRequestParams {
    /** The scope of the CDS Flow Conventions to delete. */
    scope: string;
    /** The CDS Flow Conventions to delete. */
    code: string;
}
export interface DeleteFlowConventionsRequestParams {
    /** The scope of the Flow Conventions to delete. */
    scope: string;
    /** The Flow Conventions to delete. */
    code: string;
}
export interface DeleteIndexConventionRequestParams {
    /** The scope of the Index Convention to delete. */
    scope: string;
    /** The Index Convention to delete. */
    code: string;
}
export interface GetCdsFlowConventionsRequestParams {
    /** The scope of the CDS Flow Conventions to retrieve. */
    scope: string;
    /** The name of the CDS Flow Conventions to retrieve the data for. */
    code: string;
    /** The asAt datetime at which to retrieve the CDS Flow Conventions. Defaults to return the latest version if not specified. */
    asAt?: string;
}
export interface GetFlowConventionsRequestParams {
    /** The scope of the Flow Conventions to retrieve. */
    scope: string;
    /** The name of the Flow Conventions to retrieve the data for. */
    code: string;
    /** The asAt datetime at which to retrieve the Flow Conventions. Defaults to return the latest version if not specified. */
    asAt?: string;
}
export interface GetIndexConventionRequestParams {
    /** The scope of the Index Convention to retrieve. */
    scope: string;
    /** The name of the Index Convention to retrieve the data for. */
    code: string;
    /** The asAt datetime at which to retrieve the Index Convention. Defaults to return the latest version if not specified. */
    asAt?: string;
}
export interface ListCdsFlowConventionsRequestParams {
    /** The asAt datetime at which to list the conventions. Defaults to latest if not specified. */
    asAt?: string;
}
export interface ListFlowConventionsRequestParams {
    /** The asAt datetime at which to list the conventions. Defaults to latest if not specified. */
    asAt?: string;
}
export interface ListIndexConventionRequestParams {
    /** The asAt datetime at which to list the conventions. Defaults to latest if not specified. */
    asAt?: string;
}
export interface UpsertCdsFlowConventionsRequestParams {
    /** The CDS Flow Conventions to update or insert */
    upsertCdsFlowConventionsRequest: UpsertCdsFlowConventionsRequest;
}
export interface UpsertFlowConventionsRequestParams {
    /** The Flow Conventions to update or insert */
    upsertFlowConventionsRequest: UpsertFlowConventionsRequest;
}
export interface UpsertIndexConventionRequestParams {
    /** The Index Conventions to update or insert */
    upsertIndexConventionRequest: UpsertIndexConventionRequest;
}
export declare class ConventionsService {
    protected httpClient: HttpClient;
    protected basePath: string;
    defaultHeaders: HttpHeaders;
    configuration: Configuration;
    encoder: HttpParameterCodec;
    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
    private addToHttpParams;
    private addToHttpParamsRecursive;
    /**
     * [BETA] DeleteCdsFlowConventions: Delete the CDS Flow Conventions of given scope and code, assuming that it is present.
     * Delete the specified CDS Flow Conventions from a single scope.  The response will return either detail of the deleted item, or an explanation (failure) as to why this did not succeed.  It is important to always check for any unsuccessful response.
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    deleteCdsFlowConventions(requestParameters?: DeleteCdsFlowConventionsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<AnnulSingleStructuredDataResponse>;
    deleteCdsFlowConventions(requestParameters?: DeleteCdsFlowConventionsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<AnnulSingleStructuredDataResponse>>;
    deleteCdsFlowConventions(requestParameters?: DeleteCdsFlowConventionsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<AnnulSingleStructuredDataResponse>>;
    /**
     * [BETA] DeleteFlowConventions: Delete the Flow Conventions of given scope and code, assuming that it is present.
     * Delete the specified conventions from a single scope.  The response will return either detail of the deleted item, or an explanation (failure) as to why this did not succeed.  It is important to always check for any unsuccessful response.
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    deleteFlowConventions(requestParameters?: DeleteFlowConventionsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<AnnulSingleStructuredDataResponse>;
    deleteFlowConventions(requestParameters?: DeleteFlowConventionsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<AnnulSingleStructuredDataResponse>>;
    deleteFlowConventions(requestParameters?: DeleteFlowConventionsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<AnnulSingleStructuredDataResponse>>;
    /**
     * [BETA] DeleteIndexConvention: Delete the Index Convention of given scope and code, assuming that it is present.
     * Delete the specified Index Convention from a single scope.  The response will return either detail of the deleted item, or an explanation (failure) as to why this did not succeed.  It is important to always check for any unsuccessful response.
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    deleteIndexConvention(requestParameters?: DeleteIndexConventionRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<AnnulSingleStructuredDataResponse>;
    deleteIndexConvention(requestParameters?: DeleteIndexConventionRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<AnnulSingleStructuredDataResponse>>;
    deleteIndexConvention(requestParameters?: DeleteIndexConventionRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<AnnulSingleStructuredDataResponse>>;
    /**
     * [BETA] GetCdsFlowConventions: Get CDS Flow Conventions
     * Get a CDS Flow Conventions from a single scope.  The response will return either the conventions that has been stored, or a failure explaining why the request was unsuccessful.  It is important to always check for any unsuccessful requests (failures).
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    getCdsFlowConventions(requestParameters?: GetCdsFlowConventionsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<GetCdsFlowConventionsResponse>;
    getCdsFlowConventions(requestParameters?: GetCdsFlowConventionsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<GetCdsFlowConventionsResponse>>;
    getCdsFlowConventions(requestParameters?: GetCdsFlowConventionsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<GetCdsFlowConventionsResponse>>;
    /**
     * [BETA] GetFlowConventions: Get Flow Conventions
     * Get a Flow Conventions from a single scope.  The response will return either the conventions that has been stored, or a failure explaining why the request was unsuccessful.  It is important to always check for any unsuccessful requests (failures).
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    getFlowConventions(requestParameters?: GetFlowConventionsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<GetFlowConventionsResponse>;
    getFlowConventions(requestParameters?: GetFlowConventionsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<GetFlowConventionsResponse>>;
    getFlowConventions(requestParameters?: GetFlowConventionsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<GetFlowConventionsResponse>>;
    /**
     * [BETA] GetIndexConvention: Get Index Convention
     * Get a Index Convention from a single scope.  The response will return either the conventions that has been stored, or a failure explaining why the request was unsuccessful.  It is important to always check for any unsuccessful requests (failures).
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    getIndexConvention(requestParameters?: GetIndexConventionRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<GetIndexConventionResponse>;
    getIndexConvention(requestParameters?: GetIndexConventionRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<GetIndexConventionResponse>>;
    getIndexConvention(requestParameters?: GetIndexConventionRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<GetIndexConventionResponse>>;
    /**
     * [BETA] ListCdsFlowConventions: List the set of CDS Flow Conventions
     * List the set of CDS Flow Conventions at the specified date/time
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    listCdsFlowConventions(requestParameters?: ListCdsFlowConventionsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<ResourceListOfGetCdsFlowConventionsResponse>;
    listCdsFlowConventions(requestParameters?: ListCdsFlowConventionsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<ResourceListOfGetCdsFlowConventionsResponse>>;
    listCdsFlowConventions(requestParameters?: ListCdsFlowConventionsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<ResourceListOfGetCdsFlowConventionsResponse>>;
    /**
     * [BETA] ListFlowConventions: List the set of Flow Conventions
     * List the set of Flow Conventions at the specified date/time
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    listFlowConventions(requestParameters?: ListFlowConventionsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<ResourceListOfGetFlowConventionsResponse>;
    listFlowConventions(requestParameters?: ListFlowConventionsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<ResourceListOfGetFlowConventionsResponse>>;
    listFlowConventions(requestParameters?: ListFlowConventionsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<ResourceListOfGetFlowConventionsResponse>>;
    /**
     * [BETA] ListIndexConvention: List the set of Index Conventions
     * List the set of Index Conventions at the specified date/time
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    listIndexConvention(requestParameters?: ListIndexConventionRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<ResourceListOfGetIndexConventionResponse>;
    listIndexConvention(requestParameters?: ListIndexConventionRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<ResourceListOfGetIndexConventionResponse>>;
    listIndexConvention(requestParameters?: ListIndexConventionRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<ResourceListOfGetIndexConventionResponse>>;
    /**
     * [BETA] UpsertCdsFlowConventions: Upsert a set of CDS Flow Conventions. This creates or updates the data in Lusid.
     * Update or insert CDS Flow Conventions in a single scope. An item will be updated if it already exists  and inserted if it does not.                The response will return the successfully updated or inserted CDS Flow Conventions or failure message if unsuccessful                It is important to always check to verify success (or failure).
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    upsertCdsFlowConventions(requestParameters?: UpsertCdsFlowConventionsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<UpsertSingleStructuredDataResponse>;
    upsertCdsFlowConventions(requestParameters?: UpsertCdsFlowConventionsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<UpsertSingleStructuredDataResponse>>;
    upsertCdsFlowConventions(requestParameters?: UpsertCdsFlowConventionsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<UpsertSingleStructuredDataResponse>>;
    /**
     * [BETA] UpsertFlowConventions: Upsert Flow Conventions. This creates or updates the data in Lusid.
     * Update or insert Flow Conventions in a single scope. An item will be updated if it already exists  and inserted if it does not.                The response will return the successfully updated or inserted Flow Conventions or failure message if unsuccessful                It is important to always check to verify success (or failure).
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    upsertFlowConventions(requestParameters?: UpsertFlowConventionsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<UpsertSingleStructuredDataResponse>;
    upsertFlowConventions(requestParameters?: UpsertFlowConventionsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<UpsertSingleStructuredDataResponse>>;
    upsertFlowConventions(requestParameters?: UpsertFlowConventionsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<UpsertSingleStructuredDataResponse>>;
    /**
     * [BETA] UpsertIndexConvention: Upsert a set of Index Convention. This creates or updates the data in Lusid.
     * Update or insert Index Convention in a single scope. An item will be updated if it already exists  and inserted if it does not.                The response will return the successfully updated or inserted Index Convention or failure message if unsuccessful                It is important to always check to verify success (or failure).
     * @param requestParameters
     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
     * @param reportProgress flag to report request and response progress.
     */
    upsertIndexConvention(requestParameters?: UpsertIndexConventionRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<UpsertSingleStructuredDataResponse>;
    upsertIndexConvention(requestParameters?: UpsertIndexConventionRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<UpsertSingleStructuredDataResponse>>;
    upsertIndexConvention(requestParameters?: UpsertIndexConventionRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<UpsertSingleStructuredDataResponse>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConventionsService, [null, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConventionsService>;
}