@finbourne/lusid-sdk-angular18

import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http'; import { Observable } from 'rxjs'; import { DeletedEntityResponse } from '../model/deletedEntityResponse'; import { ResourceListOfSideDefinition } from '../model/resourceListOfSideDefinition'; import { ResourceListOfTransactionType } from '../model/resourceListOfTransactionType'; import { SideDefinition } from '../model/sideDefinition'; import { SideDefinitionRequest } from '../model/sideDefinitionRequest'; import { SidesDefinitionRequest } from '../model/sidesDefinitionRequest'; import { TransactionType } from '../model/transactionType'; import { TransactionTypeRequest } from '../model/transactionTypeRequest'; import { Configuration } from '../configuration'; import * as i0 from "@angular/core"; export interface DeleteSideDefinitionRequestParams { /** The label to uniquely identify the side. */ side: string; /** The scope in which the side exists. When not supplied the scope is \'default\'. */ scope?: string; } export interface DeleteTransactionTypeRequestParams { /** The source that the type is in */ source: string; /** One of the type\'s aliases */ type: string; /** The scope in which the transaction types exists. When not supplied the scope is \'default\'. */ scope?: string; } export interface DeleteTransactionTypeSourceRequestParams { /** The source to set the transaction types for. */ source: string; /** The scope in which the transaction types exists. When not supplied the scope is \'default\'. */ scope?: string; } export interface GetSideDefinitionRequestParams { /** The label to uniquely identify the side. */ side: string; /** The scope in which the side exists. When not supplied the scope is \'default\'. */ scope?: string; /** The asAt datetime at which to retrieve the transaction types. Defaults to returning the latest versions if not specified. */ asAt?: string; } export interface GetTransactionTypeRequestParams { /** The source that the type is in */ source: string; /** One of the type\'s aliases */ type: string; /** The asAt datetime at which to retrieve the transaction configuration. Defaults to returning the latest version of the transaction configuration type if not specified */ asAt?: string; /** The scope in which the transaction types exists. When not supplied the scope is \'default\'. */ scope?: string; } export interface ListSideDefinitionsRequestParams { /** The asAt datetime at which to retrieve the transaction types. Defaults to returning the latest versions if not specified. */ asAt?: string; /** The scope in which the side exists. When not supplied the scope is \'default\'. */ scope?: string; } export interface ListTransactionTypesRequestParams { /** The asAt datetime at which to retrieve the transaction types. Defaults to returning the latest versions if not specified. */ asAt?: string; /** The scope in which the side exists. When not supplied the scope is \'default\'. */ scope?: string; } export interface SetSideDefinitionRequestParams { /** The label to uniquely identify the side. */ side: string; /** The side definition to create or replace. */ sideDefinitionRequest: SideDefinitionRequest; /** The scope in which the side exists. When not supplied the scope is \'default\'. */ scope?: string; } export interface SetSideDefinitionsRequestParams { /** The list of side definitions to create, or replace. */ sidesDefinitionRequest: Array<SidesDefinitionRequest>; /** The scope in which the side exists. When not supplied the scope is \'default\'. */ scope?: string; } export interface SetTransactionTypeRequestParams { /** The source to set the transaction configuration for */ source: string; /** One of the transaction configuration alias types to uniquely identify the configuration. If this type does not exist, then a new transaction type is created using the body of the request in the given source, without including this type */ type: string; /** The transaction configuration to set */ transactionTypeRequest: TransactionTypeRequest; /** The scope in which the transaction types exists. When not supplied the scope is \'default\'. */ scope?: string; } export interface SetTransactionTypeSourceRequestParams { /** The source to set the transaction types for. */ source: string; /** The set of transaction types. */ transactionTypeRequest: Array<TransactionTypeRequest>; /** The scope in which the transaction types exists. When not supplied the scope is \'default\'. */ scope?: string; } export declare class TransactionConfigurationService { protected httpClient: HttpClient; protected basePath: string; defaultHeaders: HttpHeaders; configuration: Configuration; encoder: HttpParameterCodec; constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration); private addToHttpParams; private addToHttpParamsRecursive; /** * DeleteSideDefinition: Delete the given side definition * Delete the side which user specify in the request. * @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. */ deleteSideDefinition(requestParameters?: DeleteSideDefinitionRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<DeletedEntityResponse>; deleteSideDefinition(requestParameters?: DeleteSideDefinitionRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<DeletedEntityResponse>>; deleteSideDefinition(requestParameters?: DeleteSideDefinitionRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<DeletedEntityResponse>>; /** * DeleteTransactionType: Delete a transaction type * /// WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change. * @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. */ deleteTransactionType(requestParameters?: DeleteTransactionTypeRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<DeletedEntityResponse>; deleteTransactionType(requestParameters?: DeleteTransactionTypeRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<DeletedEntityResponse>>; deleteTransactionType(requestParameters?: DeleteTransactionTypeRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<DeletedEntityResponse>>; /** * DeleteTransactionTypeSource: Delete all transaction types for the given source and scope * Delete all the types for the given source and scope. * @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. */ deleteTransactionTypeSource(requestParameters?: DeleteTransactionTypeSourceRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<DeletedEntityResponse>; deleteTransactionTypeSource(requestParameters?: DeleteTransactionTypeSourceRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<DeletedEntityResponse>>; deleteTransactionTypeSource(requestParameters?: DeleteTransactionTypeSourceRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<DeletedEntityResponse>>; /** * GetSideDefinition: Get the side definition for a given side name( or label) * Get the side definition user requested. * @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. */ getSideDefinition(requestParameters?: GetSideDefinitionRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<SideDefinition>; getSideDefinition(requestParameters?: GetSideDefinitionRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<SideDefinition>>; getSideDefinition(requestParameters?: GetSideDefinitionRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<SideDefinition>>; /** * GetTransactionType: Get a single transaction configuration type * Get a single transaction type. Returns failure if not found * @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. */ getTransactionType(requestParameters?: GetTransactionTypeRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<TransactionType>; getTransactionType(requestParameters?: GetTransactionTypeRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<TransactionType>>; getTransactionType(requestParameters?: GetTransactionTypeRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<TransactionType>>; /** * ListSideDefinitions: List the side definitions * List all the side definitions in the given scope * @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. */ listSideDefinitions(requestParameters?: ListSideDefinitionsRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<ResourceListOfSideDefinition>; listSideDefinitions(requestParameters?: ListSideDefinitionsRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<ResourceListOfSideDefinition>>; listSideDefinitions(requestParameters?: ListSideDefinitionsRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<ResourceListOfSideDefinition>>; /** * ListTransactionTypes: List transaction types * Get the list of current transaction types. For information on the default transaction types provided with LUSID, see https://support.lusid.com/knowledgebase/article/KA-01873/. * @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. */ listTransactionTypes(requestParameters?: ListTransactionTypesRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<{ [key: string]: Array<TransactionType>; }>; listTransactionTypes(requestParameters?: ListTransactionTypesRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<{ [key: string]: Array<TransactionType>; }>>; listTransactionTypes(requestParameters?: ListTransactionTypesRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<{ [key: string]: Array<TransactionType>; }>>; /** * SetSideDefinition: Set a side definition * Set a new side definition for use in a transaction type. For more information, see https://support.lusid.com/knowledgebase/article/KA-01875. * @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. */ setSideDefinition(requestParameters?: SetSideDefinitionRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<SideDefinition>; setSideDefinition(requestParameters?: SetSideDefinitionRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<SideDefinition>>; setSideDefinition(requestParameters?: SetSideDefinitionRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<SideDefinition>>; /** * SetSideDefinitions: Set the given side definitions * Set a new side definition for use in a transaction type. For more information, see https://support.lusid.com/knowledgebase/article/KA-01875. * @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. */ setSideDefinitions(requestParameters?: SetSideDefinitionsRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<ResourceListOfSideDefinition>; setSideDefinitions(requestParameters?: SetSideDefinitionsRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<ResourceListOfSideDefinition>>; setSideDefinitions(requestParameters?: SetSideDefinitionsRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<ResourceListOfSideDefinition>>; /** * SetTransactionType: Set a specific transaction type * Set a transaction type for the given source and type. If the requested transaction type does not exist, it will be created WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change. * @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. */ setTransactionType(requestParameters?: SetTransactionTypeRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<TransactionType>; setTransactionType(requestParameters?: SetTransactionTypeRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<TransactionType>>; setTransactionType(requestParameters?: SetTransactionTypeRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<TransactionType>>; /** * SetTransactionTypeSource: Set the transaction types for the given source and scope * The complete set of transaction types for the source. * @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. */ setTransactionTypeSource(requestParameters?: SetTransactionTypeSourceRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<ResourceListOfTransactionType>; setTransactionTypeSource(requestParameters?: SetTransactionTypeSourceRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<ResourceListOfTransactionType>>; setTransactionTypeSource(requestParameters?: SetTransactionTypeSourceRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<ResourceListOfTransactionType>>; static ɵfac: i0.ɵɵFactoryDeclaration<TransactionConfigurationService, [null, { optional: true; }, { optional: true; }]>; static ɵprov: i0.ɵɵInjectableDeclaration<TransactionConfigurationService>; }