/// <reference types="node" />
import http from 'http';
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 { Authentication, Interceptor } from '../model/models';
import { OAuth } from '../model/models';
export declare enum PortfoliosApiApiKeys {
}
export declare class PortfoliosApi {
    protected _basePath: string;
    protected _defaultHeaders: any;
    protected _useQuerystring: boolean;
    protected authentications: {
        default: Authentication;
        oauth2: OAuth;
    };
    protected interceptors: Interceptor[];
    constructor(basePath?: string);
    set useQuerystring(value: boolean);
    set basePath(basePath: string);
    set defaultHeaders(defaultHeaders: any);
    get defaultHeaders(): any;
    get basePath(): string;
    setDefaultAuthentication(auth: Authentication): void;
    setApiKey(key: PortfoliosApiApiKeys, value: string): void;
    set accessToken(token: string);
    addInterceptor(interceptor: Interceptor): void;
    /**
     * 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
     * @summary [EARLY ACCESS] BatchUpsertPortfolioAccessMetadata: Upsert multiple Portfolio Access Metadata Rules to multiple Portfolios
     * @param requestBody The Access Metadata Rules to upsert and the Portfolio identifiers to upsert for
     * @param effectiveAt The date these rules will be effective from
     * @param effectiveUntil The effective date until which the Access Metadata is valid. If not supplied, this will be valid indefinitely, or until the next \&#39;effectiveAt\&#39; date of the Access Metadata
     */
    batchUpsertPortfolioAccessMetadata(requestBody: {
        [key: string]: BatchUpsertPortfolioAccessMetadataRequest;
    }, effectiveAt?: string, effectiveUntil?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: BatchUpsertPortfolioAccessMetadataResponse;
    }>;
    /**
     * Delete a particular instruction for a particular portfolio
     * @summary [EARLY ACCESS] DeleteInstrumentEventInstruction: Delete Instrument Event Instruction
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param instrumentEventInstructionId The id of the instruction to be deleted.
     * @param portfolioEffectiveAt The effective date at which the portfolio will be resolved. Defaults to current time if not specified.
     */
    deleteInstrumentEventInstruction(scope: string, code: string, instrumentEventInstructionId: string, portfolioEffectiveAt?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: DeletedEntityResponse;
    }>;
    /**
     * Delete the Portfolio Access Metadata Rule that exactly matches the provided identifier parts
     * @summary DeleteKeyFromPortfolioAccessMetadata: Delete a Portfolio Access Metadata Rule
     * @param scope The scope of the Quote Access Metadata Rule to retrieve.
     * @param code Portfolio code
     * @param metadataKey The metadataKey identifying the access metadata entry to delete
     * @param effectiveAt The effective date to delete at, if this is not supplied, it will delete all data found
     * @param effectiveUntil The effective date until which the delete is valid. If not supplied this will be valid indefinitely, or until the next \&#39;effectiveAt\&#39; date of the Access Metadata
     */
    deleteKeyFromPortfolioAccessMetadata(scope: string, code: string, metadataKey: string, effectiveAt?: string, effectiveUntil?: Date, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: DeletedEntityResponse;
    }>;
    /**
     * 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.
     * @summary DeletePortfolio: Delete portfolio
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     */
    deletePortfolio(scope: string, code: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: DeletedEntityResponse;
    }>;
    /**
     * 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.
     * @summary DeletePortfolioProperties: Delete portfolio properties
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param propertyKeys The property keys of the properties to delete. These must take the format              {domain}/{scope}/{code}, for example \&#39;Portfolio/Manager/Id\&#39;. Each property must be from the \&#39;Portfolio\&#39; domain.
     * @param effectiveAt The effective datetime or cut label at which to delete time-variant properties from.              The property must exist at the specified \&#39;effectiveAt\&#39; datetime. If the \&#39;effectiveAt\&#39; 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.
     */
    deletePortfolioProperties(scope: string, code: string, propertyKeys: Array<string>, effectiveAt?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: DeletedEntityResponse;
    }>;
    /**
     * Cancel one or more Returns which exist into the specified portfolio.
     * @summary [EARLY ACCESS] DeletePortfolioReturns: Delete Returns
     * @param scope The scope of the Portfolio.
     * @param code The code of the  Portfolio.
     * @param returnScope The scope of the Returns.
     * @param returnCode The code of the Returns.
     * @param fromEffectiveAt The start date from which to delete the Returns.
     * @param toEffectiveAt The end date from which to delete the Returns.
     * @param period The period of the Returns to be deleted. Default value: Daily. Available values: Daily, Monthly.
     */
    deletePortfolioReturns(scope: string, code: string, returnScope: string, returnCode: string, fromEffectiveAt: string, toEffectiveAt: string, period?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: DeletedEntityResponse;
    }>;
    /**
     * 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.
     * @summary [EARLY ACCESS] GetAggregatedReturnsDispersionMetrics: Get the Aggregated Returns Dispersion metric
     * @param scope The scope of the Portfolio.
     * @param code The code of the  Portfolio.
     * @param aggregatedReturnsDispersionRequest The request used in the AggregatedReturnsDispersionMetric.
     * @param asAt The asAt datetime at which to retrieve the Returns. Defaults to the latest.
     */
    getAggregatedReturnsDispersionMetrics(scope: string, code: string, aggregatedReturnsDispersionRequest: AggregatedReturnsDispersionRequest, asAt?: Date, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: CompositeDispersionResponse;
    }>;
    /**
     * Calculate the Composite Returns and return this with the constituents which are included in this calculation
     * @summary [EARLY ACCESS] GetCompositeBreakdown: Get the Composite Breakdown on how the composite Returns are calculated
     * @param scope The scope of the Portfolio.
     * @param code The code of the  Portfolio.
     * @param compositeBreakdownRequest The request used in the GetCompositeBreakdown.
     * @param fromEffectiveAt The start date from which to calculate the Returns.
     * @param toEffectiveAt The end date for which to calculate the Returns.
     * @param asAt The asAt datetime at which to retrieve the Returns. Defaults to the latest.
     */
    getCompositeBreakdown(scope: string, code: string, compositeBreakdownRequest: CompositeBreakdownRequest, fromEffectiveAt?: string, toEffectiveAt?: string, asAt?: Date, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: CompositeBreakdownResponse;
    }>;
    /**
     * Get a particular instruction for a particular portfolio
     * @summary [EARLY ACCESS] GetInstrumentEventInstruction: Get Instrument Event Instruction
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param instrumentEventInstructionId The id of the instruction to be retrieved.
     * @param portfolioEffectiveAt The effective date at which the portfolio will be resolved. Defaults to current time if not specified.
     * @param asAt The asAt datetime at which to retrieve the instruction. Defaults to return the latest version of the instruction if not specified.
     * @param timelineScope The scope of the Timeline, used to override the AsAt, and fetch post close activity data.              If this is provided, timelineCode must also be provided.
     * @param timelineCode The code of the Timeline, used to override the AsAt, and fetch post close activity data.              If this is provided, timelineScope must also be provided.
     * @param closedPeriodId The code of the ClosedPeriod attached to the timeline, used to override the AsAt, and fetch post close activity data.              If this field is left empty and the timelineScope and timelineCode fields are filled out, the portfolioEffectiveAt will be used to resolve the relevant closed period.
     */
    getInstrumentEventInstruction(scope: string, code: string, instrumentEventInstructionId: string, portfolioEffectiveAt?: string, asAt?: Date, timelineScope?: string, timelineCode?: string, closedPeriodId?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: InstrumentEventInstruction;
    }>;
    /**
     * Retrieve the definition of a particular portfolio.
     * @summary GetPortfolio: Get portfolio
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param effectiveAt The effective datetime or cut label at which to retrieve the portfolio definition. Defaults to the current LUSID system datetime if not specified.
     * @param asAt The asAt datetime at which to retrieve the portfolio definition. Defaults to returning the latest version of the portfolio definition if not specified.
     * @param propertyKeys A list of property keys from the \&#39;Portfolio\&#39; 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 \&#39;Portfolio/Manager/Id\&#39;.
     * @param relationshipDefinitionIds 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}.
     */
    getPortfolio(scope: string, code: string, effectiveAt?: string, asAt?: Date, propertyKeys?: Array<string>, relationshipDefinitionIds?: Array<string>, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: Portfolio;
    }>;
    /**
     * Aggregate Returns which are on the specified portfolio.
     * @summary [DEPRECATED] GetPortfolioAggregateReturns: Aggregate Returns (This is a deprecated endpoint).
     * @param scope The scope of the Portfolio.
     * @param code The code of the  Portfolio.
     * @param returnScope The scope of the Returns.
     * @param returnCode The code of the Returns.
     * @param recipeIdScope The Recipe Scope for getting the fx rates
     * @param recipeIdCode The Recipe Code for getting the fx rates
     * @param fromEffectiveAt The start date from which to calculate the Returns.
     * @param toEffectiveAt The end date for which to calculate the Returns.
     * @param compositeMethod The method used to calculate the Portfolio performance. Available values: Equal, Asset.
     * @param period The type of the returns used to calculate the aggregation result. Available values: Daily, Monthly.
     * @param outputFrequency The type of calculated output. Available values: Daily, Weekly, Monthly, Quarterly, HalfYearly, Yearly.
     * @param metrics 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.
     * @param asAt The asAt datetime at which to retrieve the Returns. Defaults to the latest.
     * @param alternativeIncDate 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.
     */
    getPortfolioAggregateReturns(scope: string, code: string, returnScope: string, returnCode: string, recipeIdScope?: string, recipeIdCode?: string, fromEffectiveAt?: string, toEffectiveAt?: string, compositeMethod?: string, period?: string, outputFrequency?: string, metrics?: Array<string>, asAt?: Date, alternativeIncDate?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfAggregatedReturn;
    }>;
    /**
     * Aggregate Returns which are on the specified portfolio.
     * @summary GetPortfolioAggregatedReturns: Aggregated Returns
     * @param scope The scope of the Portfolio.
     * @param code The code of the  Portfolio.
     * @param aggregatedReturnsRequest The request used in the AggregatedReturns.
     * @param fromEffectiveAt The start date from which to calculate the Returns.
     * @param toEffectiveAt The end date for which to calculate the Returns.
     * @param asAt The asAt datetime at which to retrieve the Returns. Defaults to the latest.
     */
    getPortfolioAggregatedReturns(scope: string, code: string, aggregatedReturnsRequest: AggregatedReturnsRequest, fromEffectiveAt?: string, toEffectiveAt?: string, asAt?: Date, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: AggregatedReturnsResponse;
    }>;
    /**
     * Get all the commands that modified a particular portfolio, including any input transactions.
     * @summary GetPortfolioCommands: Get portfolio commands
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param fromAsAt The lower bound asAt datetime (inclusive) from which to retrieve commands. There is no lower bound if this is not specified.
     * @param toAsAt The upper bound asAt datetime (inclusive) from which to retrieve commands. There is no upper bound if this is not specified.
     * @param filter Expression to filter the results.              For example, to filter on the User ID, specify \&quot;userId.id eq \&#39;string\&#39;\&quot;.              For more information about filtering, see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @param page The pagination token to use to continue listing commands; this value is returned from the previous call.
     * @param limit When paginating, limit the results to this number. Defaults to 500 if not specified.
     */
    getPortfolioCommands(scope: string, code: string, fromAsAt?: Date, toAsAt?: Date, filter?: string, page?: string, limit?: number, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfProcessedCommand;
    }>;
    /**
     * Pass the scope and portfolio code parameters to retrieve the AccessMetadata associated with a portfolio
     * @summary GetPortfolioMetadata: Get access metadata rules for a portfolio
     * @param scope The scope of the Portfolio Access Metadata Rule to retrieve.
     * @param code Portfolio code
     * @param effectiveAt The effectiveAt datetime at which to retrieve the access metadata rule.
     * @param asAt The asAt datetime at which to retrieve the portfolio access metadata.
     */
    getPortfolioMetadata(scope: string, code: string, effectiveAt?: string, asAt?: Date, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: {
            [key: string]: Array<AccessMetadataValue>;
        };
    }>;
    /**
     * List all the properties of a particular portfolio.
     * @summary GetPortfolioProperties: Get portfolio properties
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param effectiveAt The effective datetime or cut label at which to list the portfolio\&#39;s properties. Defaults to the current LUSID system datetime if not specified.
     * @param asAt The asAt datetime at which to list the portfolio\&#39;s properties. Defaults to returning the latest version of each property if not specified.
     */
    getPortfolioProperties(scope: string, code: string, effectiveAt?: string, asAt?: Date, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: PortfolioProperties;
    }>;
    /**
     * Show the complete time series (history) for a particular portfolio property.
     * @summary GetPortfolioPropertyTimeSeries: Get portfolio property time series
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param propertyKey The property key of the property whose history to show.              This must be from the \&#39;Portfolio\&#39; domain and in the format {domain}/{scope}/{code}, for example \&#39;Portfolio/Manager/Id\&#39;.
     * @param portfolioEffectiveAt The effective datetime used to resolve the portfolio. Defaults to the current LUSID system datetime if not specified.
     * @param asAt The asAt datetime at which to show the history. Defaults to returning the current datetime if not supplied.
     * @param filter Expression to filter the results. For more information about filtering,              see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @param page 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.
     * @param limit When paginating, limit the results to this number.
     */
    getPortfolioPropertyTimeSeries(scope: string, code: string, propertyKey: string, portfolioEffectiveAt?: string, asAt?: Date, filter?: string, page?: string, limit?: number, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfPropertyInterval;
    }>;
    /**
     * Get relations for a particular portfolio.
     * @summary [EXPERIMENTAL] GetPortfolioRelations: Get portfolio relations
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param effectiveAt The effective datetime or cut label at which to retrieve relations. Defaults to the current LUSID system datetime if not specified.
     * @param asAt The asAt datetime at which to retrieve relations. Defaults to returning the latest LUSID AsAt time if not specified.
     * @param filter Expression to filter the relations. Provide a null or empty string for this field until further notice.
     * @param identifierTypes Identifier types (as property keys) used for referencing Persons or Legal Entities.              These must be from the \&#39;Person\&#39; or \&#39;LegalEntity\&#39; domains and have the format {domain}/{scope}/{code}, for example              \&#39;Person/CompanyDetails/Role\&#39;. Only identifier types provided will be used to look up relevant entities in relations. If not applicable, provide an empty array.
     */
    getPortfolioRelations(scope: string, code: string, effectiveAt?: string, asAt?: Date, filter?: string, identifierTypes?: Array<string>, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfRelation;
    }>;
    /**
     * Get relationships for a particular portfolio.
     * @summary GetPortfolioRelationships: Get portfolio relationships
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param effectiveAt The effective datetime or cut label at which to retrieve relationships. Defaults to the current LUSID system datetime if not specified.
     * @param asAt The asAt datetime at which to retrieve relationships. Defaults to returning the latest LUSID AsAt time if not specified.
     * @param filter Expression to filter the relationships. Provide a null or empty string for this field until further notice.
     * @param identifierTypes Identifier types (as property keys) used for referencing Persons or Legal Entities.              These can be specified from the \&#39;Person\&#39; or \&#39;LegalEntity\&#39; domains and have the format {domain}/{scope}/{code}, for example              \&#39;Person/CompanyDetails/Role\&#39;. An Empty array may be used to return all related Entities.
     */
    getPortfolioRelationships(scope: string, code: string, effectiveAt?: string, asAt?: Date, filter?: string, identifierTypes?: Array<string>, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfRelationship;
    }>;
    /**
     * Get Returns which are on the specified portfolio.
     * @summary GetPortfolioReturns: Get Returns
     * @param scope The scope of the Portfolio.
     * @param code The code of the  Portfolio.
     * @param returnScope The scope of the Returns.
     * @param returnCode The code of the Returns.
     * @param fromEffectiveAt The start date from which to get the Returns.
     * @param toEffectiveAt The end date from which to get the Returns.
     * @param period The period for which to show the Returns. Default value: Daily. Available values: Daily, Monthly.
     * @param asAt The asAt datetime at which to retrieve the Returns. Defaults to the latest.
     */
    getPortfolioReturns(scope: string, code: string, returnScope: string, returnCode: string, fromEffectiveAt?: string, toEffectiveAt?: string, period?: string, asAt?: Date, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfPerformanceReturn;
    }>;
    /**
     * Get a specific portfolio access metadata rule by specifying the corresponding identifier parts                No matching will be performed through this endpoint. To retrieve a rule, it is necessary to specify, exactly, the identifier of the rule
     * @summary [EARLY ACCESS] GetPortfoliosAccessMetadataByKey: Get an entry identified by a metadataKey in the access metadata object
     * @param scope The scope of the Portfolio Access Metadata Rule to retrieve.
     * @param code The code of the portfolio
     * @param metadataKey Key of the metadata to retrieve
     * @param effectiveAt The effective date of the rule
     * @param asAt The asAt datetime at which to retrieve the portfolio access metadata.
     */
    getPortfoliosAccessMetadataByKey(scope: string, code: string, metadataKey: string, effectiveAt?: string, asAt?: Date, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: Array<AccessMetadataValue>;
    }>;
    /**
     * Lists all instructions for a particular portfolio
     * @summary [EARLY ACCESS] ListInstrumentEventInstructions: List Instrument Event Instructions
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param portfolioEffectiveAt The effective date at which the portfolio will be resolved. Defaults to current time if not specified.
     * @param asAt The asAt datetime at which to retrieve the instructions. Defaults to latest if not specified.
     * @param page 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.
     * @param limit When paginating, limit the results to this number. Defaults to 100 if not specified.
     * @param filter Expression to filter the results. For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @param sortBy A list of field names to sort by, each suffixed by \&quot; ASC\&quot; or \&quot; DESC\&quot;.
     * @param timelineScope The scope of the Timeline, used to override the AsAt, and fetch post close activity data.              If this is provided, timelineCode must also be provided.
     * @param timelineCode The code of the Timeline, used to override the AsAt, and fetch post close activity data.              If this is provided, timelineScope must also be provided.
     * @param closedPeriodId The code of the ClosedPeriod attached to the timeline, used to override the AsAt, and fetch post close activity data.              If this field is left empty and the timelineScope and timelineCode fields are filled out, the portfolioEffectiveAt will be used to resolve the relevant closed period.
     */
    listInstrumentEventInstructions(scope: string, code: string, portfolioEffectiveAt?: string, asAt?: Date, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, timelineScope?: string, timelineCode?: string, closedPeriodId?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: PagedResourceListOfInstrumentEventInstruction;
    }>;
    /**
     * List all the properties of a particular portfolio.
     * @summary [EARLY ACCESS] ListPortfolioProperties: Get portfolio properties
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param effectiveAt The effective datetime or cut label at which to list the portfolio\&#39;s properties. Defaults to the current LUSID system datetime if not specified.
     * @param asAt The asAt datetime at which to list the portfolio\&#39;s properties. Defaults to returning the latest version of each property if not specified.
     * @param page The pagination token to use to continue listing commands; this value is returned from the previous call.
     * @param limit When paginating, limit the results per page to this number.
     */
    listPortfolioProperties(scope: string, code: string, effectiveAt?: string, asAt?: Date, page?: string, limit?: number, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfProperty;
    }>;
    /**
     * List all the portfolios matching particular criteria.
     * @summary ListPortfolios: List portfolios
     * @param effectiveAt The effective datetime or cut label at which to list the portfolios. Defaults to the current LUSID              system datetime if not specified.
     * @param asAt The asAt datetime at which to list the portfolios. Defaults to returning the latest version              of each portfolio if not specified.
     * @param page 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.
     * @param limit When paginating, limit the results to this number. Defaults to 100 if not specified.
     * @param filter Expression to filter the results.              For example, to filter on the transaction type, specify \&quot;type eq \&#39;Transaction\&#39;\&quot;. For more information about filtering              results, see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @param sortBy A list of field names or properties to sort by, each suffixed by \&quot; ASC\&quot; or \&quot; DESC\&quot;.
     * @param query 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 \&#39;LUID_PPA8HI6M\&#39; or a Figi of \&#39;BBG000BLNNH6\&#39;,              specify \&quot;instrument.identifiers in ((\&#39;LusidInstrumentId\&#39;, \&#39;LUID_PPA8HI6M\&#39;), (\&#39;Figi\&#39;, \&#39;BBG000BLNNH6\&#39;))\&quot;.
     * @param propertyKeys A list of property keys from the \&#39;Portfolio\&#39; 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 \&#39;Portfolio/Manager/Id\&#39;.
     * @param relationshipDefinitionIds 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}.
     */
    listPortfolios(effectiveAt?: string, asAt?: Date, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, query?: string, propertyKeys?: Array<string>, relationshipDefinitionIds?: Array<string>, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfPortfolio;
    }>;
    /**
     * List all the portfolios in a particular scope.
     * @summary ListPortfoliosForScope: List portfolios for scope
     * @param scope The scope whose portfolios to list.
     * @param effectiveAt The effective datetime or cut label at which to list the portfolios. Defaults to the current LUSID              system datetime if not specified.
     * @param asAt The asAt datetime at which to list the portfolios. Defaults to returning the latest version              of each portfolio if not specified.
     * @param page 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.
     * @param limit When paginating, limit the results to this number. Defaults to 100 if not specified.
     * @param filter Expression to filter the results.              For example, to return only transactions with a transaction type of \&#39;Buy\&#39;, specify \&quot;type eq \&#39;Buy\&#39;\&quot;.              For more information about filtering results, see https://support.lusid.com/knowledgebase/article/KA-01914.
     * @param sortBy A list of field names or properties to sort by, each suffixed by \&quot; ASC\&quot; or \&quot; DESC\&quot;.
     * @param propertyKeys A list of property keys from the \&#39;Portfolio\&#39; 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 \&#39;Portfolio/Manager/Id\&#39;.
     * @param relationshipDefinitionIds 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}.
     */
    listPortfoliosForScope(scope: string, effectiveAt?: string, asAt?: Date, page?: string, limit?: number, filter?: string, sortBy?: Array<string>, propertyKeys?: Array<string>, relationshipDefinitionIds?: Array<string>, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfPortfolio;
    }>;
    /**
     * Create or update certain fields for a particular  portfolio.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: Created, InstrumentScopes, Type.
     * @summary PatchPortfolio: Patch portfolio.
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the              scope this uniquely identifies the portfolio.
     * @param operation The json patch document. For more check: https://datatracker.ietf.org/doc/html/rfc6902.
     */
    patchPortfolio(scope: string, code: string, operation: Array<Operation>, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: Portfolio;
    }>;
    /**
     * Patch Portfolio Access Metadata Rules in a single scope.  The behaviour is defined by the JSON Patch specification.                Currently only \'add\' is a supported operation on the patch document.    Currently only valid metadata keys are supported paths on the patch document.    The response will return any affected Portfolio Access Metadata rules or a failure message if unsuccessful.    It is important to always check to verify success (or failure).                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.
     * @summary [EARLY ACCESS] PatchPortfolioAccessMetadata: Patch Access Metadata rules for a Portfolio.
     * @param scope The scope of the Portfolio Access Metadata Rule.
     * @param code Portfolio code
     * @param accessMetadataOperation The Json Patch document
     * @param effectiveAt The date this rule will effective from
     * @param effectiveUntil The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next \&#39;effectiveAt\&#39; date of the Access Metadata
     */
    patchPortfolioAccessMetadata(scope: string, code: string, accessMetadataOperation: Array<AccessMetadataOperation>, effectiveAt?: string, effectiveUntil?: Date, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: {
            [key: string]: Array<AccessMetadataValue>;
        };
    }>;
    /**
     * Update the definition of a particular portfolio.                Note that not all elements of a portfolio definition are  modifiable due to the potential implications for data already stored.
     * @summary UpdatePortfolio: Update portfolio
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param updatePortfolioRequest The updated portfolio definition.
     * @param effectiveAt The effective datetime or cut label at which to update the definition. Defaults to the current               LUSID system datetime if not specified.
     */
    updatePortfolio(scope: string, code: string, updatePortfolioRequest: UpdatePortfolioRequest, effectiveAt?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: Portfolio;
    }>;
    /**
     * Batch upsert for instrument event instructions, for the portfolio or individual holdings
     * @summary [EARLY ACCESS] UpsertInstrumentEventInstructions: Upsert Instrument Event Instructions
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param successMode Whether the batch request should fail atomically or in a partial fashion - allowed values: Atomic, Partial (default)
     * @param requestBody The instructions to be upserted to the portfolio.
     * @param portfolioEffectiveAt The effective date at which the portfolio will be resolved. Defaults to current time if not specified.
     */
    upsertInstrumentEventInstructions(scope: string, code: string, successMode: string, requestBody: {
        [key: string]: InstrumentEventInstructionRequest;
    }, portfolioEffectiveAt?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: InstrumentEventInstructionsResponse;
    }>;
    /**
     * Update or insert one Portfolio Access Metadata Rule in a single scope. An item will be updated if it already exists  and inserted if it does not.    The response will return the successfully updated or inserted Portfolio Access Metadata Rule or failure message if unsuccessful    It is important to always check to verify success (or failure).                Multiple rules for a metadataKey can exists with different effective at dates, when resources are accessed the rule that is active for the current time will be fetched
     * @summary UpsertPortfolioAccessMetadata: Upsert a Portfolio Access Metadata Rule associated with specific metadataKey. This creates or updates the data in LUSID.
     * @param scope The scope to use when updating or inserting the Portfolio Access Metadata Rule.
     * @param code Portfolio code
     * @param metadataKey Key of the access metadata to upsert
     * @param upsertPortfolioAccessMetadataRequest The Portfolio Access Metadata Rule to update or insert
     * @param effectiveAt The date this rule will effective from
     * @param effectiveUntil The effective date until which the Access Metadata is valid. If not supplied this will be valid indefinitely, or until the next \&#39;effectiveAt\&#39; date of the Access Metadata
     */
    upsertPortfolioAccessMetadata(scope: string, code: string, metadataKey: string, upsertPortfolioAccessMetadataRequest: UpsertPortfolioAccessMetadataRequest, effectiveAt?: string, effectiveUntil?: Date, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfAccessMetadataValueOf;
    }>;
    /**
     * Create or update one or more properties for a particular portfolio. A property is updated if it  already exists and created if it does not. All properties must be from the \'Portfolio\' domain.                Properties have an <i>effectiveFrom</i> datetime from which the property is valid, and an <i>effectiveUntil</i>  datetime until which it is valid. Not supplying an <i>effectiveUntil</i> datetime results in the property being  valid indefinitely, or until the next <i>effectiveFrom</i> datetime of the property.
     * @summary UpsertPortfolioProperties: Upsert portfolio properties
     * @param scope The scope of the portfolio.
     * @param code The code of the portfolio. Together with the scope this uniquely identifies the portfolio.
     * @param requestBody 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               \&#39;Portfolio/Manager/Id\&#39;.
     */
    upsertPortfolioProperties(scope: string, code: string, requestBody: {
        [key: string]: Property;
    }, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: PortfolioProperties;
    }>;
    /**
     * Update or insert returns into the specified portfolio.
     * @summary UpsertPortfolioReturns: Upsert Returns
     * @param scope The scope of the Portfolio.
     * @param code The code of the  Portfolio.
     * @param returnScope The scope of the Returns.
     * @param returnCode The code of the Returns.
     * @param performanceReturn This contains the Returns which need to be upsert.
     */
    upsertPortfolioReturns(scope: string, code: string, returnScope: string, returnCode: string, performanceReturn: Array<PerformanceReturn>, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: UpsertReturnsResponse;
    }>;
}
