@finbourne/lusid-sdk-angular18/lib/.generated/api/counterparties.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 { GetCounterpartyAgreementResponse } from '../model/getCounterpartyAgreementResponse';
import { GetCreditSupportAnnexResponse } from '../model/getCreditSupportAnnexResponse';
import { ResourceListOfGetCounterpartyAgreementResponse } from '../model/resourceListOfGetCounterpartyAgreementResponse';
import { ResourceListOfGetCreditSupportAnnexResponse } from '../model/resourceListOfGetCreditSupportAnnexResponse';
import { UpsertCounterpartyAgreementRequest } from '../model/upsertCounterpartyAgreementRequest';
import { UpsertCreditSupportAnnexRequest } from '../model/upsertCreditSupportAnnexRequest';
import { UpsertSingleStructuredDataResponse } from '../model/upsertSingleStructuredDataResponse';
import { Configuration } from '../configuration';
import * as i0 from "@angular/core";
export interface DeleteCounterpartyAgreementRequestParams {
    /** The scope of the Counterparty Agreement to delete. */
    scope: string;
    /** The Counterparty Agreement to delete. */
    code: string;
}
export interface DeleteCreditSupportAnnexRequestParams {
    /** The scope of the Credit Support Annex to delete. */
    scope: string;
    /** The Credit Support Annex to delete. */
    code: string;
}
export interface GetCounterpartyAgreementRequestParams {
    /** The scope of the Counterparty Agreement to retrieve. */
    scope: string;
    /** The name of the Counterparty Agreement to retrieve the data for. */
    code: string;
    /** The asAt datetime at which to retrieve the Counterparty Agreement. Defaults to return the latest version if not specified. */
    asAt?: string;
}
export interface GetCreditSupportAnnexRequestParams {
    /** The scope of the Credit Support Annex to retrieve. */
    scope: string;
    /** The name of the Credit Support Annex to retrieve the data for. */
    code: string;
    /** The asAt datetime at which to retrieve the Credit Support Annex . Defaults to return the latest version if not specified. */
    asAt?: string;
}
export interface ListCounterpartyAgreementsRequestParams {
    /** The asAt datetime at which to list the Counterparty Agreements. Defaults to latest if not specified. */
    asAt?: string;
}
export interface ListCreditSupportAnnexesRequestParams {
    /** The asAt datetime at which to list the Credit Support Annexes. Defaults to latest if not specified. */
    asAt?: string;
}
export interface UpsertCounterpartyAgreementRequestParams {
    /** The Counterparty Agreement to update or insert */
    upsertCounterpartyAgreementRequest: UpsertCounterpartyAgreementRequest;
}
export interface UpsertCreditSupportAnnexRequestParams {
    /** The Credit Support Annex to update or insert */
    upsertCreditSupportAnnexRequest: UpsertCreditSupportAnnexRequest;
}
export declare class CounterpartiesService {
    protected httpClient: HttpClient;
    protected basePath: string;
    defaultHeaders: HttpHeaders;
    configuration: Configuration;
    encoder: HttpParameterCodec;
    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
    private addToHttpParams;
    private addToHttpParamsRecursive;
    /**
     * [EARLY ACCESS] DeleteCounterpartyAgreement: Delete the Counterparty Agreement of given scope and code
     * Delete the specified Counterparty Agreement 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.
     */
    deleteCounterpartyAgreement(requestParameters?: DeleteCounterpartyAgreementRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<AnnulSingleStructuredDataResponse>;
    deleteCounterpartyAgreement(requestParameters?: DeleteCounterpartyAgreementRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<AnnulSingleStructuredDataResponse>>;
    deleteCounterpartyAgreement(requestParameters?: DeleteCounterpartyAgreementRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<AnnulSingleStructuredDataResponse>>;
    /**
     * [EARLY ACCESS] DeleteCreditSupportAnnex: Delete the Credit Support Annex of given scope and code
     * Delete the specified Credit Support Annex 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.
     */
    deleteCreditSupportAnnex(requestParameters?: DeleteCreditSupportAnnexRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<AnnulSingleStructuredDataResponse>;
    deleteCreditSupportAnnex(requestParameters?: DeleteCreditSupportAnnexRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<AnnulSingleStructuredDataResponse>>;
    deleteCreditSupportAnnex(requestParameters?: DeleteCreditSupportAnnexRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<AnnulSingleStructuredDataResponse>>;
    /**
     * [EARLY ACCESS] GetCounterpartyAgreement: Get Counterparty Agreement
     * Get a Counterparty Agreement from a single scope.  The response will return either the Counterparty Agreement 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.
     */
    getCounterpartyAgreement(requestParameters?: GetCounterpartyAgreementRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<GetCounterpartyAgreementResponse>;
    getCounterpartyAgreement(requestParameters?: GetCounterpartyAgreementRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<GetCounterpartyAgreementResponse>>;
    getCounterpartyAgreement(requestParameters?: GetCounterpartyAgreementRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<GetCounterpartyAgreementResponse>>;
    /**
     * [EARLY ACCESS] GetCreditSupportAnnex: Get Credit Support Annex
     * Get a Credit Support Annex from a single scope.  The response will return either the Credit Support Annex 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.
     */
    getCreditSupportAnnex(requestParameters?: GetCreditSupportAnnexRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<GetCreditSupportAnnexResponse>;
    getCreditSupportAnnex(requestParameters?: GetCreditSupportAnnexRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<GetCreditSupportAnnexResponse>>;
    getCreditSupportAnnex(requestParameters?: GetCreditSupportAnnexRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<GetCreditSupportAnnexResponse>>;
    /**
     * [EARLY ACCESS] ListCounterpartyAgreements: List the set of Counterparty Agreements
     * List the set of Counterparty Agreements at the specified AsAt 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.
     */
    listCounterpartyAgreements(requestParameters?: ListCounterpartyAgreementsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<ResourceListOfGetCounterpartyAgreementResponse>;
    listCounterpartyAgreements(requestParameters?: ListCounterpartyAgreementsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<ResourceListOfGetCounterpartyAgreementResponse>>;
    listCounterpartyAgreements(requestParameters?: ListCounterpartyAgreementsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<ResourceListOfGetCounterpartyAgreementResponse>>;
    /**
     * [EARLY ACCESS] ListCreditSupportAnnexes: List the set of Credit Support Annexes
     * List the set of Credit Support Annexes at the specified AsAt 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.
     */
    listCreditSupportAnnexes(requestParameters?: ListCreditSupportAnnexesRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<ResourceListOfGetCreditSupportAnnexResponse>;
    listCreditSupportAnnexes(requestParameters?: ListCreditSupportAnnexesRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<ResourceListOfGetCreditSupportAnnexResponse>>;
    listCreditSupportAnnexes(requestParameters?: ListCreditSupportAnnexesRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<ResourceListOfGetCreditSupportAnnexResponse>>;
    /**
     * [EARLY ACCESS] UpsertCounterpartyAgreement: Upsert Counterparty Agreement
     * Update or insert Counterparty Agreement 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 Counterparty Agreement 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.
     */
    upsertCounterpartyAgreement(requestParameters?: UpsertCounterpartyAgreementRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<UpsertSingleStructuredDataResponse>;
    upsertCounterpartyAgreement(requestParameters?: UpsertCounterpartyAgreementRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<UpsertSingleStructuredDataResponse>>;
    upsertCounterpartyAgreement(requestParameters?: UpsertCounterpartyAgreementRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<UpsertSingleStructuredDataResponse>>;
    /**
     * [EARLY ACCESS] UpsertCreditSupportAnnex: Upsert Credit Support Annex
     * Update or insert Credit Support Annex 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 Credit Support Annex 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.
     */
    upsertCreditSupportAnnex(requestParameters?: UpsertCreditSupportAnnexRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<UpsertSingleStructuredDataResponse>;
    upsertCreditSupportAnnex(requestParameters?: UpsertCreditSupportAnnexRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpResponse<UpsertSingleStructuredDataResponse>>;
    upsertCreditSupportAnnex(requestParameters?: UpsertCreditSupportAnnexRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
        httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
        context?: HttpContext;
        transferCache?: boolean;
    }): Observable<HttpEvent<UpsertSingleStructuredDataResponse>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CounterpartiesService, [null, { optional: true; }, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CounterpartiesService>;
}