@finbourne/lusid-sdk-angular18

import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http'; import { Observable } from 'rxjs'; import { AccessMetadataOperation } from '../model/accessMetadataOperation'; import { AccessMetadataValue } from '../model/accessMetadataValue'; import { AggregatedReturnsDispersionRequest } from '../model/aggregatedReturnsDispersionRequest'; import { AggregatedReturnsRequest } from '../model/aggregatedReturnsRequest'; import { AggregatedReturnsResponse } from '../model/aggregatedReturnsResponse'; import { BatchUpsertPortfolioAccessMetadataRequest } from '../model/batchUpsertPortfolioAccessMetadataRequest'; import { BatchUpsertPortfolioAccessMetadataResponse } from '../model/batchUpsertPortfolioAccessMetadataResponse'; import { CompositeBreakdownRequest } from '../model/compositeBreakdownRequest'; import { CompositeBreakdownResponse } from '../model/compositeBreakdownResponse'; import { CompositeDispersionResponse } from '../model/compositeDispersionResponse'; import { DeletedEntityResponse } from '../model/deletedEntityResponse'; import { InstrumentEventInstruction } from '../model/instrumentEventInstruction'; import { InstrumentEventInstructionRequest } from '../model/instrumentEventInstructionRequest'; import { InstrumentEventInstructionsResponse } from '../model/instrumentEventInstructionsResponse'; import { Operation } from '../model/operation'; import { PagedResourceListOfInstrumentEventInstruction } from '../model/pagedResourceListOfInstrumentEventInstruction'; import { PerformanceReturn } from '../model/performanceReturn'; import { Portfolio } from '../model/portfolio'; import { PortfolioProperties } from '../model/portfolioProperties'; import { Property } from '../model/property'; import { ResourceListOfAccessMetadataValueOf } from '../model/resourceListOfAccessMetadataValueOf'; import { ResourceListOfAggregatedReturn } from '../model/resourceListOfAggregatedReturn'; import { ResourceListOfPerformanceReturn } from '../model/resourceListOfPerformanceReturn'; import { ResourceListOfPortfolio } from '../model/resourceListOfPortfolio'; import { ResourceListOfProcessedCommand } from '../model/resourceListOfProcessedCommand'; import { ResourceListOfProperty } from '../model/resourceListOfProperty'; import { ResourceListOfPropertyInterval } from '../model/resourceListOfPropertyInterval'; import { ResourceListOfRelation } from '../model/resourceListOfRelation'; import { ResourceListOfRelationship } from '../model/resourceListOfRelationship'; import { UpdatePortfolioRequest } from '../model/updatePortfolioRequest'; import { UpsertPortfolioAccessMetadataRequest } from '../model/upsertPortfolioAccessMetadataRequest'; import { UpsertReturnsResponse } from '../model/upsertReturnsResponse'; import { Configuration } from '../configuration'; import * as i0 from "@angular/core"; export interface BatchUpsertPortfolioAccessMetadataRequestParams { /** The Access Metadata Rules to upsert and the Portfolio identifiers to upsert for */ requestBody: { [key: string]: BatchUpsertPortfolioAccessMetadataRequest; }; /** The date these rules will be effective from */ effectiveAt?: string; /** The effective date until which the Access Metadata is valid. If not supplied, this will be valid indefinitely, or until the next \'effectiveAt\' date of the Access Metadata */ effectiveUntil?: string; } export interface DeleteInstrumentEventInstructionRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The id of the instruction to be deleted. */ instrumentEventInstructionId: string; /** The effective date at which the portfolio will be resolved. Defaults to current time if not specified. */ portfolioEffectiveAt?: string; } export interface DeleteKeyFromPortfolioAccessMetadataRequestParams { /** The scope of the Quote Access Metadata Rule to retrieve. */ scope: string; /** Portfolio code */ code: string; /** The metadataKey identifying the access metadata entry to delete */ metadataKey: string; /** The effective date to delete at, if this is not supplied, it will delete all data found */ effectiveAt?: string; /** The effective date until which the delete is valid. If not supplied this will be valid indefinitely, or until the next \'effectiveAt\' date of the Access Metadata */ effectiveUntil?: string; } export interface DeletePortfolioRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; } export interface DeletePortfolioPropertiesRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The property keys of the properties to delete. These must take the format {domain}/{scope}/{code}, for example \'Portfolio/Manager/Id\'. Each property must be from the \'Portfolio\' domain. */ propertyKeys: Array<string>; /** The effective datetime or cut label at which to delete time-variant properties from. The property must exist at the specified \'effectiveAt\' datetime. If the \'effectiveAt\' is not provided or is before the time-variant property exists then a failure is returned. Do not specify this parameter if any of the properties to delete are perpetual. */ effectiveAt?: string; } export interface DeletePortfolioReturnsRequestParams { /** The scope of the Portfolio. */ scope: string; /** The code of the Portfolio. */ code: string; /** The scope of the Returns. */ returnScope: string; /** The code of the Returns. */ returnCode: string; /** The start date from which to delete the Returns. */ fromEffectiveAt: string; /** The end date from which to delete the Returns. */ toEffectiveAt: string; /** The Period (Daily or Monthly) of the Returns to be deleted. Defaults to Daily. */ period?: string; } export interface GetAggregatedReturnsDispersionMetricsRequestParams { /** The scope of the Portfolio. */ scope: string; /** The code of the Portfolio. */ code: string; /** The request used in the AggregatedReturnsDispersionMetric. */ aggregatedReturnsDispersionRequest: AggregatedReturnsDispersionRequest; /** The asAt datetime at which to retrieve the Returns. Defaults to the latest. */ asAt?: string; } export interface GetCompositeBreakdownRequestParams { /** The scope of the Portfolio. */ scope: string; /** The code of the Portfolio. */ code: string; /** The request used in the GetCompositeBreakdown. */ compositeBreakdownRequest: CompositeBreakdownRequest; /** The start date from which to calculate the Returns. */ fromEffectiveAt?: string; /** The end date for which to calculate the Returns. */ toEffectiveAt?: string; /** The asAt datetime at which to retrieve the Returns. Defaults to the latest. */ asAt?: string; } export interface GetInstrumentEventInstructionRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The id of the instruction to be retrieved. */ instrumentEventInstructionId: string; /** The effective date at which the portfolio will be resolved. Defaults to current time if not specified. */ portfolioEffectiveAt?: string; /** The asAt datetime at which to retrieve the instruction. Defaults to return the latest version of the instruction if not specified. */ asAt?: string; } export interface GetPortfolioRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The effective datetime or cut label at which to retrieve the portfolio definition. Defaults to the current LUSID system datetime if not specified. */ effectiveAt?: string; /** The asAt datetime at which to retrieve the portfolio definition. Defaults to returning the latest version of the portfolio definition if not specified. */ asAt?: string; /** A list of property keys from the \'Portfolio\' domain to decorate onto the portfolio, or from any domain that supports relationships to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example \'Portfolio/Manager/Id\'. */ propertyKeys?: Array<string>; /** A list of relationship definitions that are used to decorate related entities onto the portfolio in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}. */ relationshipDefinitionIds?: Array<string>; } export interface GetPortfolioAggregateReturnsRequestParams { /** The scope of the Portfolio. */ scope: string; /** The code of the Portfolio. */ code: string; /** The scope of the Returns. */ returnScope: string; /** The code of the Returns. */ returnCode: string; /** The Recipe Scope for getting the fx rates */ recipeIdScope?: string; /** The Recipe Code for getting the fx rates */ recipeIdCode?: string; /** The start date from which to calculate the Returns. */ fromEffectiveAt?: string; /** The end date for which to calculate the Returns. */ toEffectiveAt?: string; /** The method used to calculate the Portfolio performance: Equal/Asset. */ compositeMethod?: string; /** The type of the returns used to calculate the aggregation result: Daily/Monthly. */ period?: string; /** The type of calculated output: Daily/Weekly/Monthly/Quarterly/Half-Yearly/Yearly. */ outputFrequency?: string; /** Determines what type of returns should be calculated, see https://support.lusid.com/knowledgebase/article/KA-01675/en-us for a list of available metrics. */ metrics?: Array<string>; /** The asAt datetime at which to retrieve the Returns. Defaults to the latest. */ asAt?: string; /** The date from which to consider the Returns on the Portfolio, if this is different from the date when Returns begin. Can be a date string or Portfolio property. */ alternativeIncDate?: string; } export interface GetPortfolioAggregatedReturnsRequestParams { /** The scope of the Portfolio. */ scope: string; /** The code of the Portfolio. */ code: string; /** The request used in the AggregatedReturns. */ aggregatedReturnsRequest: AggregatedReturnsRequest; /** The start date from which to calculate the Returns. */ fromEffectiveAt?: string; /** The end date for which to calculate the Returns. */ toEffectiveAt?: string; /** The asAt datetime at which to retrieve the Returns. Defaults to the latest. */ asAt?: string; } export interface GetPortfolioCommandsRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The lower bound asAt datetime (inclusive) from which to retrieve commands. There is no lower bound if this is not specified. */ fromAsAt?: string; /** The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified. */ toAsAt?: string; /** Expression to filter the results. For example, to filter on the User ID, specify \"userId.id eq \'string\'\". For more information about filtering, see https://support.lusid.com/knowledgebase/article/KA-01914. */ filter?: string; /** The pagination token to use to continue listing commands; this value is returned from the previous call. */ page?: string; /** When paginating, limit the results to this number. Defaults to 500 if not specified. */ limit?: number; } export interface GetPortfolioMetadataRequestParams { /** The scope of the Portfolio Access Metadata Rule to retrieve. */ scope: string; /** Portfolio code */ code: string; /** The effectiveAt datetime at which to retrieve the access metadata rule. */ effectiveAt?: string; /** The asAt datetime at which to retrieve the portfolio access metadata. */ asAt?: string; } export interface GetPortfolioPropertiesRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The effective datetime or cut label at which to list the portfolio\'s properties. Defaults to the current LUSID system datetime if not specified. */ effectiveAt?: string; /** The asAt datetime at which to list the portfolio\'s properties. Defaults to returning the latest version of each property if not specified. */ asAt?: string; } export interface GetPortfolioPropertyTimeSeriesRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The property key of the property whose history to show. This must be from the \'Portfolio\' domain and in the format {domain}/{scope}/{code}, for example \'Portfolio/Manager/Id\'. */ propertyKey: string; /** The effective datetime used to resolve the portfolio. Defaults to the current LUSID system datetime if not specified. */ portfolioEffectiveAt?: string; /** The asAt datetime at which to show the history. Defaults to returning the current datetime if not supplied. */ asAt?: string; /** Expression to filter the results. For more information about filtering, see https://support.lusid.com/knowledgebase/article/KA-01914. */ filter?: string; /** The pagination token to use to continue listing properties; this value is returned from the previous call. If a pagination token is provided, the filter, portfolioEffectiveAt, and asAt fields must not have changed since the original request. */ page?: string; /** When paginating, limit the results to this number. */ limit?: number; } export interface GetPortfolioRelationsRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The effective datetime or cut label at which to retrieve relations. Defaults to the current LUSID system datetime if not specified. */ effectiveAt?: string; /** The asAt datetime at which to retrieve relations. Defaults to returning the latest LUSID AsAt time if not specified. */ asAt?: string; /** Expression to filter the relations. Provide a null or empty string for this field until further notice. */ filter?: string; /** Identifier types (as property keys) used for referencing Persons or Legal Entities. These must be from the \'Person\' or \'LegalEntity\' domains and have the format {domain}/{scope}/{code}, for example \'Person/CompanyDetails/Role\'. Only identifier types provided will be used to look up relevant entities in relations. If not applicable, provide an empty array. */ identifierTypes?: Array<string>; } export interface GetPortfolioRelationshipsRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The effective datetime or cut label at which to retrieve relationships. Defaults to the current LUSID system datetime if not specified. */ effectiveAt?: string; /** The asAt datetime at which to retrieve relationships. Defaults to returning the latest LUSID AsAt time if not specified. */ asAt?: string; /** Expression to filter the relationships. Provide a null or empty string for this field until further notice. */ filter?: string; /** Identifier types (as property keys) used for referencing Persons or Legal Entities. These can be specified from the \'Person\' or \'LegalEntity\' domains and have the format {domain}/{scope}/{code}, for example \'Person/CompanyDetails/Role\'. An Empty array may be used to return all related Entities. */ identifierTypes?: Array<string>; } export interface GetPortfolioReturnsRequestParams { /** The scope of the Portfolio. */ scope: string; /** The code of the Portfolio. */ code: string; /** The scope of the Returns. */ returnScope: string; /** The code of the Returns. */ returnCode: string; /** The start date from which to get the Returns. */ fromEffectiveAt?: string; /** The end date from which to get the Returns. */ toEffectiveAt?: string; /** Show the Returns on a Daily or Monthly period. Defaults to Daily. */ period?: string; /** The asAt datetime at which to retrieve the Returns. Defaults to the latest. */ asAt?: string; } export interface GetPortfoliosAccessMetadataByKeyRequestParams { /** The scope of the Portfolio Access Metadata Rule to retrieve. */ scope: string; /** The code of the portfolio */ code: string; /** Key of the metadata to retrieve */ metadataKey: string; /** The effective date of the rule */ effectiveAt?: string; /** The asAt datetime at which to retrieve the portfolio access metadata. */ asAt?: string; } export interface ListInstrumentEventInstructionsRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The effective date at which the portfolio will be resolved. Defaults to current time if not specified. */ portfolioEffectiveAt?: string; /** The asAt datetime at which to retrieve the instructions. Defaults to latest if not specified. */ asAt?: string; /** The pagination token to use to continue listing instructions; this value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt and asAt fields must not have changed since the original request. */ page?: string; /** When paginating, limit the results to this number. Defaults to 100 if not specified. */ limit?: number; /** Expression to filter the results. For more information about filtering results, see https://support.lusid.com/knowledgebase/article/KA-01914. */ filter?: string; /** A list of field names to sort by, each suffixed by \" ASC\" or \" DESC\". */ sortBy?: Array<string>; } export interface ListPortfolioPropertiesRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The effective datetime or cut label at which to list the portfolio\'s properties. Defaults to the current LUSID system datetime if not specified. */ effectiveAt?: string; /** The asAt datetime at which to list the portfolio\'s properties. Defaults to returning the latest version of each property if not specified. */ asAt?: string; /** The pagination token to use to continue listing commands; this value is returned from the previous call. */ page?: string; /** When paginating, limit the results per page to this number. */ limit?: number; } export interface ListPortfoliosRequestParams { /** The effective datetime or cut label at which to list the portfolios. Defaults to the current LUSID system datetime if not specified. */ effectiveAt?: string; /** The asAt datetime at which to list the portfolios. Defaults to returning the latest version of each portfolio if not specified. */ asAt?: string; /** The pagination token to use to continue listing portfolios; this value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt and asAt fields must not have changed since the original request. */ page?: string; /** When paginating, limit the results to this number. Defaults to 100 if not specified. */ limit?: number; /** Expression to filter the results. For example, to filter on the transaction type, specify \"type eq \'Transaction\'\". For more information about filtering results, see https://support.lusid.com/knowledgebase/article/KA-01914. */ filter?: string; /** A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\". */ sortBy?: Array<string>; /** Expression specifying the criteria that the returned portfolios must meet. For example, to see which portfolios have holdings in instruments with a LusidInstrumentId (LUID) of \'LUID_PPA8HI6M\' or a Figi of \'BBG000BLNNH6\', specify \"instrument.identifiers in ((\'LusidInstrumentId\', \'LUID_PPA8HI6M\'), (\'Figi\', \'BBG000BLNNH6\'))\". */ query?: string; /** A list of property keys from the \'Portfolio\' domain to decorate onto each portfolio, or from any domain that supports relationships to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example \'Portfolio/Manager/Id\'. */ propertyKeys?: Array<string>; /** A list of relationship definitions that are used to decorate related entities onto the portfolios in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}. */ relationshipDefinitionIds?: Array<string>; } export interface ListPortfoliosForScopeRequestParams { /** The scope whose portfolios to list. */ scope: string; /** The effective datetime or cut label at which to list the portfolios. Defaults to the current LUSID system datetime if not specified. */ effectiveAt?: string; /** The asAt datetime at which to list the portfolios. Defaults to returning the latest version of each portfolio if not specified. */ asAt?: string; /** The pagination token to use to continue listing portfolios. This value is returned from the previous call. If a pagination token is provided, the filter, effectiveAt and asAt fields must not have changed since the original request. */ page?: string; /** When paginating, limit the results to this number. Defaults to 100 if not specified. */ limit?: number; /** Expression to filter the results. For example, to return only transactions with a transaction type of \'Buy\', specify \"type eq \'Buy\'\". For more information about filtering results, see https://support.lusid.com/knowledgebase/article/KA-01914. */ filter?: string; /** A list of field names or properties to sort by, each suffixed by \" ASC\" or \" DESC\". */ sortBy?: Array<string>; /** A list of property keys from the \'Portfolio\' domain to decorate onto each portfolio, or from any domain that supports relationships to decorate onto related entities. These must take the format {domain}/{scope}/{code}, for example \'Portfolio/Manager/Id\'. */ propertyKeys?: Array<string>; /** A list of relationship definitions that are used to decorate related entities onto the portfolios in the response. These must take the form {relationshipDefinitionScope}/{relationshipDefinitionCode}. */ relationshipDefinitionIds?: Array<string>; } export interface PatchPortfolioRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The json patch document. For more check: https://datatracker.ietf.org/doc/html/rfc6902. */ operation: Array<Operation>; } export interface PatchPortfolioAccessMetadataRequestParams { /** The scope of the Portfolio Access Metadata Rule. */ scope: string; /** Portfolio code */ code: string; /** The Json Patch document */ accessMetadataOperation: Array<AccessMetadataOperation>; /** The date this rule will effective from */ effectiveAt?: string; /** The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next \'effectiveAt\' date of the Access Metadata */ effectiveUntil?: string; } export interface UpdatePortfolioRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The updated portfolio definition. */ updatePortfolioRequest: UpdatePortfolioRequest; /** The effective datetime or cut label at which to update the definition. Defaults to the current LUSID system datetime if not specified. */ effectiveAt?: string; } export interface UpsertInstrumentEventInstructionsRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** Whether the batch request should fail atomically or in a partial fashion - allowed values: Atomic, Partial (default) */ successMode: string; /** The instructions to be upserted to the portfolio. */ requestBody: { [key: string]: InstrumentEventInstructionRequest; }; /** The effective date at which the portfolio will be resolved. Defaults to current time if not specified. */ portfolioEffectiveAt?: string; } export interface UpsertPortfolioAccessMetadataRequestParams { /** The scope to use when updating or inserting the Portfolio Access Metadata Rule. */ scope: string; /** Portfolio code */ code: string; /** Key of the access metadata to upsert */ metadataKey: string; /** The Portfolio Access Metadata Rule to update or insert */ upsertPortfolioAccessMetadataRequest: UpsertPortfolioAccessMetadataRequest; /** The date this rule will effective from */ effectiveAt?: string; /** The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next \'effectiveAt\' date of the Access Metadata */ effectiveUntil?: string; } export interface UpsertPortfolioPropertiesRequestParams { /** The scope of the portfolio. */ scope: string; /** The code of the portfolio. Together with the scope this uniquely identifies the portfolio. */ code: string; /** The properties to be created or updated. Each property in the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code}, for example \'Portfolio/Manager/Id\'. */ requestBody: { [key: string]: Property; }; } export interface UpsertPortfolioReturnsRequestParams { /** The scope of the Portfolio. */ scope: string; /** The code of the Portfolio. */ code: string; /** The scope of the Returns. */ returnScope: string; /** The code of the Returns. */ returnCode: string; /** This contains the Returns which need to be upsert. */ performanceReturn: Array<PerformanceReturn>; } export declare class PortfoliosService { 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] BatchUpsertPortfolioAccessMetadata: Upsert multiple Portfolio Access Metadata Rules to multiple Portfolios * Update or insert multiple Access Metadata rules for multiple Portfolios. Items will be updated if they already exist and inserted if they do not. No other items will be affected The response will return the successfully updated or inserted Portfolio Access Metadata Rules or a failure message if unsuccessful Multiple rules for a metadataKey can exist with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched * @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. */ batchUpsertPortfolioAccessMetadata(requestParameters?: BatchUpsertPortfolioAccessMetadataRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<BatchUpsertPortfolioAccessMetadataResponse>; batchUpsertPortfolioAccessMetadata(requestParameters?: BatchUpsertPortfolioAccessMetadataRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<BatchUpsertPortfolioAccessMetadataResponse>>; batchUpsertPortfolioAccessMetadata(requestParameters?: BatchUpsertPortfolioAccessMetadataRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<BatchUpsertPortfolioAccessMetadataResponse>>; /** * [EARLY ACCESS] DeleteInstrumentEventInstruction: Delete Instrument Event Instruction * Delete a particular instruction for a particular portfolio * @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. */ deleteInstrumentEventInstruction(requestParameters?: DeleteInstrumentEventInstructionRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<DeletedEntityResponse>; deleteInstrumentEventInstruction(requestParameters?: DeleteInstrumentEventInstructionRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<DeletedEntityResponse>>; deleteInstrumentEventInstruction(requestParameters?: DeleteInstrumentEventInstructionRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<DeletedEntityResponse>>; /** * DeleteKeyFromPortfolioAccessMetadata: Delete a Portfolio Access Metadata Rule * Delete the Portfolio Access Metadata Rule that exactly matches the provided identifier parts * @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. */ deleteKeyFromPortfolioAccessMetadata(requestParameters?: DeleteKeyFromPortfolioAccessMetadataRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<DeletedEntityResponse>; deleteKeyFromPortfolioAccessMetadata(requestParameters?: DeleteKeyFromPortfolioAccessMetadataRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<DeletedEntityResponse>>; deleteKeyFromPortfolioAccessMetadata(requestParameters?: DeleteKeyFromPortfolioAccessMetadataRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<DeletedEntityResponse>>; /** * DeletePortfolio: Delete portfolio * Delete a particular portfolio. The deletion will take effect from the portfolio\'s creation datetime. This means that the portfolio will no longer exist at any effective datetime, as per the asAt datetime of deletion. * @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. */ deletePortfolio(requestParameters?: DeletePortfolioRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<DeletedEntityResponse>; deletePortfolio(requestParameters?: DeletePortfolioRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<DeletedEntityResponse>>; deletePortfolio(requestParameters?: DeletePortfolioRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<DeletedEntityResponse>>; /** * DeletePortfolioProperties: Delete portfolio properties * Delete one or more properties from a particular portfolio. If the properties are time-variant then an effective datetime from which to delete properties must be specified. If the properties are perpetual then it is invalid to specify an effective datetime for deletion. * @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. */ deletePortfolioProperties(requestParameters?: DeletePortfolioPropertiesRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<DeletedEntityResponse>; deletePortfolioProperties(requestParameters?: DeletePortfolioPropertiesRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<DeletedEntityResponse>>; deletePortfolioProperties(requestParameters?: DeletePortfolioPropertiesRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<DeletedEntityResponse>>; /** * [EARLY ACCESS] DeletePortfolioReturns: Delete Returns * Cancel one or more Returns which exist into the specified portfolio. * @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. */ deletePortfolioReturns(requestParameters?: DeletePortfolioReturnsRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<DeletedEntityResponse>; deletePortfolioReturns(requestParameters?: DeletePortfolioReturnsRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<DeletedEntityResponse>>; deletePortfolioReturns(requestParameters?: DeletePortfolioReturnsRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<DeletedEntityResponse>>; /** * [EARLY ACCESS] GetAggregatedReturnsDispersionMetrics: Get the Aggregated Returns Dispersion metric * Calculate the dispersion metric with the Aggregate Returns which are on the specified portfolio. This works only for composites which have at least 6 constituents for a full year in. * @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. */ getAggregatedReturnsDispersionMetrics(requestParameters?: GetAggregatedReturnsDispersionMetricsRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<CompositeDispersionResponse>; getAggregatedReturnsDispersionMetrics(requestParameters?: GetAggregatedReturnsDispersionMetricsRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<CompositeDispersionResponse>>; getAggregatedReturnsDispersionMetrics(requestParameters?: GetAggregatedReturnsDispersionMetricsRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<CompositeDispersionResponse>>; /** * [EARLY ACCESS] GetCompositeBreakdown: Get the Composite Breakdown on how the composite Returns are calculated * Calculate the Composite Returns and return this with the constituents which are included in this calculation * @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. */ getCompositeBreakdown(requestParameters?: GetCompositeBreakdownRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<CompositeBreakdownResponse>; getCompositeBreakdown(requestParameters?: GetCompositeBreakdownRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<CompositeBreakdownResponse>>; getCompositeBreakdown(requestParameters?: GetCompositeBreakdownRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<CompositeBreakdownResponse>>; /** * [EARLY ACCESS] GetInstrumentEventInstruction: Get Instrument Event Instruction * Get a particular instruction for a particular portfolio * @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. */ getInstrumentEventInstruction(requestParameters?: GetInstrumentEventInstructionRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<InstrumentEventInstruction>; getInstrumentEventInstruction(requestParameters?: GetInstrumentEventInstructionRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<InstrumentEventInstruction>>; getInstrumentEventInstruction(requestParameters?: GetInstrumentEventInstructionRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<InstrumentEventInstruction>>; /** * GetPortfolio: Get portfolio * Retrieve the definition of a particular portfolio. * @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. */ getPortfolio(requestParameters?: GetPortfolioRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<Portfolio>; getPortfolio(requestParameters?: GetPortfolioRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<Portfolio>>; getPortfolio(requestParameters?: GetPortfolioRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<Portfolio>>; /** * [DEPRECATED] GetPortfolioAggregateReturns: Aggregate Returns (This is a deprecated endpoint). * Aggregate Returns which are on the specified portfolio. * @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. */ getPortfolioAggregateReturns(requestParameters?: GetPortfolioAggregateReturnsRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<ResourceListOfAggregatedReturn>; getPortfolioAggregateReturns(requestParameters?: GetPortfolioAggregateReturnsRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<ResourceListOfAggregatedReturn>>; getPortfolioAggregateReturns(requestParameters?: GetPortfolioAggregateReturnsRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<ResourceListOfAggregatedReturn>>; /** * GetPortfolioAggregatedReturns: Aggregated Returns * Aggregate Returns which are on the specified portfolio. * @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. */ getPortfolioAggregatedReturns(requestParameters?: GetPortfolioAggregatedReturnsRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<AggregatedReturnsResponse>; getPortfolioAggregatedReturns(requestParameters?: GetPortfolioAggregatedReturnsRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<AggregatedReturnsResponse>>; getPortfolioAggregatedReturns(requestParameters?: GetPortfolioAggregatedReturnsRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<AggregatedReturnsResponse>>; /** * GetPortfolioCommands: Get portfolio commands * Get all the commands that modified a particular portfolio, including any input transactions. * @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. */ getPortfolioCommands(requestParameters?: GetPortfolioCommandsRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<ResourceListOfProcessedCommand>; getPortfolioCommands(requestParameters?: GetPortfolioCommandsRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<ResourceListOfProcessedCommand>>; getPortfolioCommands(requestParameters?: GetPortfolioCommandsRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<ResourceListOfProcessedCommand>>; /** * GetPortfolioMetadata: Get access metadata rules for a portfolio * Pass the scope and portfolio code parameters to retrieve the AccessMetadata associated with a portfolio * @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. */ getPortfolioMetadata(requestParameters?: GetPortfolioMetadataRequestParams, observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<{ [key: string]: Array<AccessMetadataValue>; }>; getPortfolioMetadata(requestParameters?: GetPortfolioMetadataRequestParams, observe?: 'response', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpResponse<{ [key: string]: Array<AccessMetadataValue>; }>>; getPortfolioMetadata(requestParameters?: GetPortfolioMetadataRequestParams, observe?: 'events', reportProgress?: boolean, options?: { httpHeaderAccept?: 'text/plain' | 'application/json' | 'text/json'; context?: HttpContext; transferCache?: boolean; }): Observable<HttpEvent<{ [key: string]: Array<AccessMetadataValue>; }>>; /** * GetPortfolioProperties: Get portfolio properties * List all the pr