@finbourne/lusid-sdk-angular16
Version:
An angular (16) SDK for secure access to the LUSID® by FINBOURNE web API
528 lines • 107 kB
TypeScript
import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
import { Observable } from 'rxjs';
import { AdjustHolding } from '../model/adjustHolding';
import { AdjustHoldingForDateRequest } from '../model/adjustHoldingForDateRequest';
import { AdjustHoldingRequest } from '../model/adjustHoldingRequest';
import { BatchAdjustHoldingsResponse } from '../model/batchAdjustHoldingsResponse';
import { BatchUpsertPortfolioTransactionsResponse } from '../model/batchUpsertPortfolioTransactionsResponse';
import { BucketedCashFlowRequest } from '../model/bucketedCashFlowRequest';
import { BucketedCashFlowResponse } from '../model/bucketedCashFlowResponse';
import { CreatePortfolioDetails } from '../model/createPortfolioDetails';
import { CreateTradeTicketsResponse } from '../model/createTradeTicketsResponse';
import { CreateTransactionPortfolioRequest } from '../model/createTransactionPortfolioRequest';
import { CustodianAccount } from '../model/custodianAccount';
import { CustodianAccountProperties } from '../model/custodianAccountProperties';
import { CustodianAccountRequest } from '../model/custodianAccountRequest';
import { CustodianAccountsUpsertResponse } from '../model/custodianAccountsUpsertResponse';
import { DeleteCustodianAccountsResponse } from '../model/deleteCustodianAccountsResponse';
import { DeletedEntityResponse } from '../model/deletedEntityResponse';
import { HoldingIdsRequest } from '../model/holdingIdsRequest';
import { HoldingsAdjustment } from '../model/holdingsAdjustment';
import { LusidTradeTicket } from '../model/lusidTradeTicket';
import { Operation } from '../model/operation';
import { PagedResourceListOfCustodianAccount } from '../model/pagedResourceListOfCustodianAccount';
import { PerpetualProperty } from '../model/perpetualProperty';
import { Portfolio } from '../model/portfolio';
import { PortfolioDetails } from '../model/portfolioDetails';
import { Property } from '../model/property';
import { ResourceId } from '../model/resourceId';
import { ResourceListOfChangeHistory } from '../model/resourceListOfChangeHistory';
import { ResourceListOfHoldingsAdjustmentHeader } from '../model/resourceListOfHoldingsAdjustmentHeader';
import { ResourceListOfInstrumentCashFlow } from '../model/resourceListOfInstrumentCashFlow';
import { ResourceListOfOutputTransaction } from '../model/resourceListOfOutputTransaction';
import { ResourceListOfPortfolioCashFlow } from '../model/resourceListOfPortfolioCashFlow';
import { ResourceListOfPortfolioCashLadder } from '../model/resourceListOfPortfolioCashLadder';
import { ResourceListOfTransaction } from '../model/resourceListOfTransaction';
import { TransactionQueryParameters } from '../model/transactionQueryParameters';
import { TransactionRequest } from '../model/transactionRequest';
import { UpsertPortfolioTransactionsResponse } from '../model/upsertPortfolioTransactionsResponse';
import { UpsertTransactionPropertiesResponse } from '../model/upsertTransactionPropertiesResponse';
import { VersionedResourceListOfA2BDataRecord } from '../model/versionedResourceListOfA2BDataRecord';
import { VersionedResourceListOfA2BMovementRecord } from '../model/versionedResourceListOfA2BMovementRecord';
import { VersionedResourceListOfHoldingContributor } from '../model/versionedResourceListOfHoldingContributor';
import { VersionedResourceListOfOutputTransaction } from '../model/versionedResourceListOfOutputTransaction';
import { VersionedResourceListOfPortfolioHolding } from '../model/versionedResourceListOfPortfolioHolding';
import { VersionedResourceListOfTransaction } from '../model/versionedResourceListOfTransaction';
import { VersionedResourceListWithWarningsOfPortfolioHolding } from '../model/versionedResourceListWithWarningsOfPortfolioHolding';
import { Configuration } from '../configuration';
import * as i0 from "@angular/core";
export declare class TransactionPortfoliosService {
protected httpClient: HttpClient;
protected basePath: string;
defaultHeaders: HttpHeaders;
configuration: Configuration;
encoder: HttpParameterCodec;
constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
private addToHttpParams;
private addToHttpParamsRecursive;
/**
* AdjustHoldings: Adjust holdings
* Adjust one or more holdings of the specified transaction portfolio to the provided targets. LUSID will automatically construct adjustment transactions to ensure that the holdings which have been adjusted are always set to the provided targets for the specified effective datetime. Read more about the difference between adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param effectiveAt The effective datetime or cut label at which the holdings should be set to the provided targets.
* @param adjustHoldingRequest The selected set of holdings to adjust to the provided targets for the transaction portfolio.
* @param reconciliationMethods Optional parameter for specifying a reconciliation method: e.g. FxForward.
* @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.
*/
adjustHoldings(scope: string, code: string, effectiveAt: string, adjustHoldingRequest: Array<AdjustHoldingRequest>, reconciliationMethods?: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<AdjustHolding>;
adjustHoldings(scope: string, code: string, effectiveAt: string, adjustHoldingRequest: Array<AdjustHoldingRequest>, reconciliationMethods?: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<AdjustHolding>>;
adjustHoldings(scope: string, code: string, effectiveAt: string, adjustHoldingRequest: Array<AdjustHoldingRequest>, reconciliationMethods?: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<AdjustHolding>>;
/**
* [EARLY ACCESS] BatchAdjustHoldings: Batch adjust holdings
* Adjust one or more holdings of the specified transaction portfolio to the provided targets. LUSID will automatically construct adjustment transactions to ensure that the holdings which have been adjusted are always set to the provided targets for the specified effective datetime in each request. Each request must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID. It serves only as a way to easily identify each adjustment in the response. Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param successMode Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial
* @param requestBody The selected set of holdings to adjust to the provided targets for the transaction portfolio.
* @param reconciliationMethods Optional parameter for specifying a reconciliation method: e.g. FxForward.
* @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.
*/
batchAdjustHoldings(scope: string, code: string, successMode: string, requestBody: {
[key: string]: AdjustHoldingForDateRequest;
}, reconciliationMethods?: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<BatchAdjustHoldingsResponse>;
batchAdjustHoldings(scope: string, code: string, successMode: string, requestBody: {
[key: string]: AdjustHoldingForDateRequest;
}, reconciliationMethods?: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<BatchAdjustHoldingsResponse>>;
batchAdjustHoldings(scope: string, code: string, successMode: string, requestBody: {
[key: string]: AdjustHoldingForDateRequest;
}, reconciliationMethods?: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<BatchAdjustHoldingsResponse>>;
/**
* [EARLY ACCESS] BatchCreateTradeTickets: Batch Create Trade Tickets
* Batch create trade tickets. Each ticket is broadly equivalent to a singular call to upsert an instrument, then a counterparty and finally a transaction that makes use of the two.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param lusidTradeTicket the trade tickets to create
* @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.
*/
batchCreateTradeTickets(scope: string, code: string, lusidTradeTicket: Array<LusidTradeTicket>, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<CreateTradeTicketsResponse>;
batchCreateTradeTickets(scope: string, code: string, lusidTradeTicket: Array<LusidTradeTicket>, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<CreateTradeTicketsResponse>>;
batchCreateTradeTickets(scope: string, code: string, lusidTradeTicket: Array<LusidTradeTicket>, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<CreateTradeTicketsResponse>>;
/**
* [EARLY ACCESS] BatchSetHoldings: Batch set holdings
* Set the holdings of the specified transaction portfolio to the provided targets. LUSID will automatically construct adjustment transactions to ensure that the entire set of holdings for the transaction portfolio are always set to the provided targets for the specified effective datetime. Read more about the difference between adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings. Each request must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID. It serves only as a way to easily identify each adjustment in the response. Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param successMode Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial
* @param requestBody The selected set of holdings to adjust to the provided targets for the transaction portfolio.
* @param reconciliationMethods Optional parameter for specifying a reconciliation method: e.g. FxForward.
* @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.
*/
batchSetHoldings(scope: string, code: string, successMode: string, requestBody: {
[key: string]: AdjustHoldingForDateRequest;
}, reconciliationMethods?: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<BatchAdjustHoldingsResponse>;
batchSetHoldings(scope: string, code: string, successMode: string, requestBody: {
[key: string]: AdjustHoldingForDateRequest;
}, reconciliationMethods?: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<BatchAdjustHoldingsResponse>>;
batchSetHoldings(scope: string, code: string, successMode: string, requestBody: {
[key: string]: AdjustHoldingForDateRequest;
}, reconciliationMethods?: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<BatchAdjustHoldingsResponse>>;
/**
* [EARLY ACCESS] BatchUpsertTransactions: Batch upsert transactions
* Create or update transactions in the transaction portfolio. A transaction will be updated if it already exists and created if it does not. Each request must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID. It serves only as a way to easily identify each transaction in the response. Note: If using partial failure modes, then it is important to check the response body for failures as any failures will still return a 200 status code
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param successMode Whether the batch request should fail Atomically or in a Partial fashion - Allowed Values: Atomic, Partial.
* @param requestBody The payload describing the transactions to be created or updated.
* @param preserveProperties If set to false, the entire property set will be overwritten by the provided properties. If not specified or set to true, only the properties provided will be updated.
* @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.
*/
batchUpsertTransactions(scope: string, code: string, successMode: string, requestBody: {
[key: string]: TransactionRequest;
}, preserveProperties?: boolean, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<BatchUpsertPortfolioTransactionsResponse>;
batchUpsertTransactions(scope: string, code: string, successMode: string, requestBody: {
[key: string]: TransactionRequest;
}, preserveProperties?: boolean, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<BatchUpsertPortfolioTransactionsResponse>>;
batchUpsertTransactions(scope: string, code: string, successMode: string, requestBody: {
[key: string]: TransactionRequest;
}, preserveProperties?: boolean, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<BatchUpsertPortfolioTransactionsResponse>>;
/**
* BuildTransactions: Build transactions
* Builds and returns all transactions that affect the holdings of a portfolio over a given interval of effective time into a set of output transactions. This includes transactions automatically generated by LUSID such as holding adjustments.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param transactionQueryParameters The query queryParameters which control how the output transactions are built.
* @param asAt The asAt datetime at which to build the transactions. Defaults to return the latest version of each transaction if not specified.
* @param filter Expression to filter the result set. For example, to return only transactions with a transaction type of \'Buy\', specify \"type eq \'Buy\'\". For more information about filtering LUSID results, see https://support.lusid.com/knowledgebase/article/KA-01914.
* @param propertyKeys A list of property keys from the \"Instrument\" or \"Transaction\" domain to decorate onto the transactions. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\" or \"Transaction/strategy/quantsignal\".
* @param limit When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.
* @param page The pagination token to use to continue listing transactions from a previous call to BuildTransactions.
* @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.
*/
buildTransactions(scope: string, code: string, transactionQueryParameters: TransactionQueryParameters, asAt?: string, filter?: string, propertyKeys?: Array<string>, limit?: number, page?: string, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<VersionedResourceListOfOutputTransaction>;
buildTransactions(scope: string, code: string, transactionQueryParameters: TransactionQueryParameters, asAt?: string, filter?: string, propertyKeys?: Array<string>, limit?: number, page?: string, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<VersionedResourceListOfOutputTransaction>>;
buildTransactions(scope: string, code: string, transactionQueryParameters: TransactionQueryParameters, asAt?: string, filter?: string, propertyKeys?: Array<string>, limit?: number, page?: string, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<VersionedResourceListOfOutputTransaction>>;
/**
* CancelAdjustHoldings: Cancel adjust holdings
* Cancel all previous holding adjustments made on the specified transaction portfolio for a specified effective datetime. This should be used to undo holding adjustments made via set holdings or adjust holdings.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param effectiveAt The effective datetime or cut label at which the holding adjustments should be undone.
* @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.
*/
cancelAdjustHoldings(scope: string, code: string, effectiveAt: string, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<DeletedEntityResponse>;
cancelAdjustHoldings(scope: string, code: string, effectiveAt: string, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<DeletedEntityResponse>>;
cancelAdjustHoldings(scope: string, code: string, effectiveAt: string, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<DeletedEntityResponse>>;
/**
* CancelTransactions: Cancel transactions
* Cancel one or more transactions from the transaction portfolio.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param transactionIds The IDs of the transactions to cancel.
* @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.
*/
cancelTransactions(scope: string, code: string, transactionIds: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<DeletedEntityResponse>;
cancelTransactions(scope: string, code: string, transactionIds: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<DeletedEntityResponse>>;
cancelTransactions(scope: string, code: string, transactionIds: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<DeletedEntityResponse>>;
/**
* CreatePortfolio: Create portfolio
* Create a transaction portfolio in a particular scope.
* @param scope The scope in which to create the transaction portfolio.
* @param createTransactionPortfolioRequest The definition of the transaction portfolio.
* @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.
*/
createPortfolio(scope: string, createTransactionPortfolioRequest: CreateTransactionPortfolioRequest, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<Portfolio>;
createPortfolio(scope: string, createTransactionPortfolioRequest: CreateTransactionPortfolioRequest, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<Portfolio>>;
createPortfolio(scope: string, createTransactionPortfolioRequest: CreateTransactionPortfolioRequest, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<Portfolio>>;
/**
* [EARLY ACCESS] CreateTradeTicket: Create Trade Ticket
* Upsert a trade ticket. Broadly equivalent to a singular call to upsert an instrument, then a counterparty and finally a transaction that makes use of the two. It can be viewed as a utility function or part of a workflow more familiar to users with OTC systems than flow and equity trading ones.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param lusidTradeTicket the trade ticket to upsert
* @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.
*/
createTradeTicket(scope: string, code: string, lusidTradeTicket?: LusidTradeTicket, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<LusidTradeTicket>;
createTradeTicket(scope: string, code: string, lusidTradeTicket?: LusidTradeTicket, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<LusidTradeTicket>>;
createTradeTicket(scope: string, code: string, lusidTradeTicket?: LusidTradeTicket, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<LusidTradeTicket>>;
/**
* [EXPERIMENTAL] DeleteCustodianAccounts: Soft or hard delete multiple custodian accounts
* Delete one or more custodian accounts from the Transaction Portfolios. Soft deletion marks the custodian account as inactive While the Hard deletion is deleting the custodian account. The batch limit per request is 2,000.
* @param scope The scope of the Transaction Portfolios.
* @param code The code of the Transaction Portfolios. Together with the scope this uniquely identifies the Transaction Portfolios.
* @param resourceId The scope and codes of the custodian accounts to delete.
* @param deleteMode The delete mode to use (defaults to \'Soft\').
* @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.
*/
deleteCustodianAccounts(scope: string, code: string, resourceId: Array<ResourceId>, deleteMode?: 'Soft' | 'Hard', observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<DeleteCustodianAccountsResponse>;
deleteCustodianAccounts(scope: string, code: string, resourceId: Array<ResourceId>, deleteMode?: 'Soft' | 'Hard', observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<DeleteCustodianAccountsResponse>>;
deleteCustodianAccounts(scope: string, code: string, resourceId: Array<ResourceId>, deleteMode?: 'Soft' | 'Hard', observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<DeleteCustodianAccountsResponse>>;
/**
* DeletePropertiesFromTransaction: Delete properties from transaction
* Delete one or more properties from a single transaction in a transaction portfolio.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param transactionId The unique ID of the transaction from which to delete properties.
* @param propertyKeys The property keys of the properties to delete. These must be from the \"Transaction\" domain and have the format {domain}/{scope}/{code}, for example \"Transaction/strategy/quantsignal\".
* @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.
*/
deletePropertiesFromTransaction(scope: string, code: string, transactionId: string, propertyKeys: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<DeletedEntityResponse>;
deletePropertiesFromTransaction(scope: string, code: string, transactionId: string, propertyKeys: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<DeletedEntityResponse>>;
deletePropertiesFromTransaction(scope: string, code: string, transactionId: string, propertyKeys: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<DeletedEntityResponse>>;
/**
* GetA2BData: Get A2B data
* Get an A2B report for the given portfolio.
* @param scope The scope of the portfolio to retrieve the A2B report for.
* @param code The code of the portfolio to retrieve the A2B report for. Together with the scope this uniquely identifies the portfolio.
* @param fromEffectiveAt The lower bound effective datetime or cut label (inclusive) from which to retrieve the data. There is no lower bound if this is not specified.
* @param toEffectiveAt The upper bound effective datetime or cut label (inclusive) from which to retrieve the data. There is no upper bound if this is not specified.
* @param asAt The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version of each transaction if not specified.
* @param recipeIdScope The scope of the given recipeId
* @param recipeIdCode The code of the given recipeId
* @param propertyKeys A list of property keys from the \"Instrument\" domain to decorate onto the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".
* @param filter Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
* @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.
*/
getA2BData(scope: string, code: string, fromEffectiveAt: string, toEffectiveAt: string, asAt?: string, recipeIdScope?: string, recipeIdCode?: string, propertyKeys?: Array<string>, filter?: string, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<VersionedResourceListOfA2BDataRecord>;
getA2BData(scope: string, code: string, fromEffectiveAt: string, toEffectiveAt: string, asAt?: string, recipeIdScope?: string, recipeIdCode?: string, propertyKeys?: Array<string>, filter?: string, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<VersionedResourceListOfA2BDataRecord>>;
getA2BData(scope: string, code: string, fromEffectiveAt: string, toEffectiveAt: string, asAt?: string, recipeIdScope?: string, recipeIdCode?: string, propertyKeys?: Array<string>, filter?: string, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<VersionedResourceListOfA2BDataRecord>>;
/**
* GetA2BMovements: Get an A2B report at the movement level for the given portfolio.
* Get an A2B report at the movement level for the given portfolio.
* @param scope The scope of the portfolio to retrieve the A2B movement report for.
* @param code The code of the portfolio to retrieve the A2B movement report for. Together with the scope this uniquely identifies the portfolio.
* @param fromEffectiveAt The lower bound effective datetime or cut label (inclusive) from which to retrieve the data. There is no lower bound if this is not specified.
* @param toEffectiveAt The upper bound effective datetime or cut label (inclusive) from which to retrieve the data. There is no upper bound if this is not specified.
* @param asAt The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version of each transaction if not specified.
* @param recipeIdScope The scope of the given recipeId
* @param recipeIdCode The code of the given recipeId
* @param propertyKeys A list of property keys from the \"Instrument\" domain to decorate onto the results. These take the format {domain}/{scope}/{code} e.g. \"Instrument/system/Name\".
* @param filter Expression to filter the result set. Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
* @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.
*/
getA2BMovements(scope: string, code: string, fromEffectiveAt: string, toEffectiveAt: string, asAt?: string, recipeIdScope?: string, recipeIdCode?: string, propertyKeys?: Array<string>, filter?: string, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<VersionedResourceListOfA2BMovementRecord>;
getA2BMovements(scope: string, code: string, fromEffectiveAt: string, toEffectiveAt: string, asAt?: string, recipeIdScope?: string, recipeIdCode?: string, propertyKeys?: Array<string>, filter?: string, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<VersionedResourceListOfA2BMovementRecord>>;
getA2BMovements(scope: string, code: string, fromEffectiveAt: string, toEffectiveAt: string, asAt?: string, recipeIdScope?: string, recipeIdCode?: string, propertyKeys?: Array<string>, filter?: string, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<VersionedResourceListOfA2BMovementRecord>>;
/**
* [EXPERIMENTAL] GetBucketedCashFlows: Get bucketed cash flows from a list of portfolios
* We bucket/aggregate a transaction portfolio\'s instruments by date or tenor specified in the request. The cashflows are grouped by both instrumentId and currency. If you want transactional level cashflow, please use the \'GetUpsertableCashFlows\' endpoint. If you want instrument cashflow, please use the \'GetPortfolioCashFlows\' endpoint. Note that these endpoints do not apply bucketing.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the portfolio.
* @param bucketedCashFlowRequest Request specifying the bucketing of cashflows
* @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.
*/
getBucketedCashFlows(scope: string, code: string, bucketedCashFlowRequest?: BucketedCashFlowRequest, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<BucketedCashFlowResponse>;
getBucketedCashFlows(scope: string, code: string, bucketedCashFlowRequest?: BucketedCashFlowRequest, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<BucketedCashFlowResponse>>;
getBucketedCashFlows(scope: string, code: string, bucketedCashFlowRequest?: BucketedCashFlowRequest, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<BucketedCashFlowResponse>>;
/**
* [EXPERIMENTAL] GetCustodianAccount: Get Custodian Account
* Retrieve the definition of a particular Custodian Account which is part of a Transaction Portfolios.
* @param scope The scope of the Transaction Portfolio.
* @param code The code of the Transaction Portfolio. Together with the scope this uniquely identifies the Transaction Portfolio.
* @param custodianAccountScope The scope of the Custodian Account.
* @param custodianAccountCode The code of the Custodian Account.
* @param effectiveAt The effective datetime or cut label at which to retrieve the Custodian Account properties. Defaults to the current LUSID system datetime if not specified.
* @param asAt The asAt datetime at which to retrieve the Custodian Account definition. Defaults to returning the latest version of the Custodian Account definition if not specified.
* @param propertyKeys A list of property keys from the \'CustodianAccount\' domain to decorate onto the Custodian Account. These must take the format {domain}/{scope}/{code}, for example \'CustodianAccount/Manager/Id\'. If not provided will return all the entitled properties for that Custodian Account.
* @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.
*/
getCustodianAccount(scope: string, code: string, custodianAccountScope: string, custodianAccountCode: string, effectiveAt?: string, asAt?: string, propertyKeys?: Array<string>, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<CustodianAccount>;
getCustodianAccount(scope: string, code: string, custodianAccountScope: string, custodianAccountCode: string, effectiveAt?: string, asAt?: string, propertyKeys?: Array<string>, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<CustodianAccount>>;
getCustodianAccount(scope: string, code: string, custodianAccountScope: string, custodianAccountCode: string, effectiveAt?: string, asAt?: string, propertyKeys?: Array<string>, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<CustodianAccount>>;
/**
* GetDetails: Get details
* Get certain details associated with a transaction portfolio.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param effectiveAt The effective datetime or cut label at which to retrieve the details of the transaction portfolio. Defaults to the current LUSID system datetime if not specified.
* @param asAt The asAt datetime at which to retrieve the details of the transaction portfolio. Defaults to returning the latest version of the details if not specified.
* @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.
*/
getDetails(scope: string, code: string, effectiveAt?: string, asAt?: string, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<PortfolioDetails>;
getDetails(scope: string, code: string, effectiveAt?: string, asAt?: string, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<PortfolioDetails>>;
getDetails(scope: string, code: string, effectiveAt?: string, asAt?: string, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<PortfolioDetails>>;
/**
* [EARLY ACCESS] GetHoldingContributors: Get Holdings Contributors
* Lists all transactions that affect the holdings of a portfolio over a given effective interval. This includes transactions automatically generated by LUSID such as holding adjustments.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param holdingId The unique holding identifier
* @param effectiveDate Effective date
* @param fromTradeDate The from trade date, defaults to first time this holding is opened, lower bound for transactions
* @param toTradeDate The to trade date upper bound date, defaults to effectiveDate. upper bound for transactions
* @param includeHistoric If true, transactions from previously closed holdings are returned. If false, only transactions from last time position is opened.
* @param taxLotId Constrains the Holding Contributors to those which contributed to the specified tax lot.
* @param limit When paginating, limit the number of returned results to this many. Defaults to 100 if not specified.
* @param asAt The asAt datetime at which to build the transactions. Defaults to return the latest version of each transaction if not specified.
* @param page The pagination token to use to continue listing transactions from a previous call to GetHoldingContributors.
* @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.
*/
getHoldingContributors(scope: string, code: string, holdingId: number, effectiveDate?: string, fromTradeDate?: string, toTradeDate?: string, includeHistoric?: boolean, taxLotId?: string, limit?: number, asAt?: string, page?: string, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<VersionedResourceListOfHoldingContributor>;
getHoldingContributors(scope: string, code: string, holdingId: number, effectiveDate?: string, fromTradeDate?: string, toTradeDate?: string, includeHistoric?: boolean, taxLotId?: string, limit?: number, asAt?: string, page?: string, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<VersionedResourceListOfHoldingContributor>>;
getHoldingContributors(scope: string, code: string, holdingId: number, effectiveDate?: string, fromTradeDate?: string, toTradeDate?: string, includeHistoric?: boolean, taxLotId?: string, limit?: number, asAt?: string, page?: string, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<VersionedResourceListOfHoldingContributor>>;
/**
* GetHoldings: Get holdings
* Calculate holdings for a transaction portfolio.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param effectiveAt The effective datetime or cut label at which to retrieve the holdings of the transaction portfolio. Defaults to the current LUSID system datetime if not specified.
* @param asAt The asAt datetime at which to retrieve the holdings of the transaction portfolio. Defaults to return the latest version if not specified.
* @param filter Expression to filter the result set. For example, to filter on the Holding Type, use \"holdingType eq \'p\'\". For more information about filtering LUSID results, see https://support.lusid.com/knowledgebase/article/KA-01914.
* @param propertyKeys A list of property keys from the \"Instrument\", \"Holding\", \"Custodian Account\" or \"Portfolio\" domain to decorate onto holdings. These must have the format {domain}/{scope}/{code}, for example \"Instrument/system/Name\" or \"Holding/system/Cost\".
* @param byTaxlots Whether or not to expand the holdings to return the underlying tax-lots. Defaults to False.
* @param includeSettlementEventsAfterDays Number of days ahead to bring back settlements from, in relation to the specified effectiveAt
* @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.
*/
getHoldings(scope: string, code: string, effectiveAt?: string, asAt?: string, filter?: string, propertyKeys?: Array<string>, byTaxlots?: boolean, includeSettlementEventsAfterDays?: number, observe?: 'body', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<VersionedResourceListOfPortfolioHolding>;
getHoldings(scope: string, code: string, effectiveAt?: string, asAt?: string, filter?: string, propertyKeys?: Array<string>, byTaxlots?: boolean, includeSettlementEventsAfterDays?: number, observe?: 'response', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpResponse<VersionedResourceListOfPortfolioHolding>>;
getHoldings(scope: string, code: string, effectiveAt?: string, asAt?: string, filter?: string, propertyKeys?: Array<string>, byTaxlots?: boolean, includeSettlementEventsAfterDays?: number, observe?: 'events', reportProgress?: boolean, options?: {
httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json';
context?: HttpContext;
}): Observable<HttpEvent<VersionedResourceListOfPortfolioHolding>>;
/**
* GetHoldingsAdjustment: Get holdings adjustment
* Get a holdings adjustment made to a transaction portfolio at a specific effective datetime. Note that a holdings adjustment will only be returned if one exists for the specified effective datetime.
* @param scope The scope of the transaction portfolio.
* @param code The code of the transaction portfolio. Together with the scope this uniquely identifies the transaction portfolio.
* @param effectiveAt The effective datetime or cut label of the holdings adjustment.
* @param asAt The asAt datetime at which to retrieve the holdings adjustment. Defaults to the return the latest version of the holdings adjustment if not specified.
* @param propertyKeys A list of property keys from the ‘Instrument\' domain to decorate onto holdings adjustments. These must have the format {domain}/{scope}/{code}, for example \'Instrument/system/Name\'. Note that properties from the \'Holding’ domain are automatically returned.
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @p