/// <reference types="node" />
import http = require('http');
import { AccessMetadataValue } from '../model/accessMetadataValue';
import { DeletedEntityResponse } from '../model/deletedEntityResponse';
import { Portfolio } from '../model/portfolio';
import { PortfolioProperties } from '../model/portfolioProperties';
import { Property } from '../model/property';
import { ResourceListOfAccessMetadataValueOf } from '../model/resourceListOfAccessMetadataValueOf';
import { ResourceListOfPortfolio } from '../model/resourceListOfPortfolio';
import { ResourceListOfProcessedCommand } from '../model/resourceListOfProcessedCommand';
import { UpdatePortfolioRequest } from '../model/updatePortfolioRequest';
import { UpsertPortfolioAccessMetadataRequest } from '../model/upsertPortfolioAccessMetadataRequest';
import { Authentication } 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;
    };
    constructor(basePath?: string);
    set useQuerystring(value: boolean);
    set basePath(basePath: string);
    get basePath(): string;
    setDefaultAuthentication(auth: Authentication): void;
    setApiKey(key: PortfoliosApiApiKeys, value: string): void;
    set accessToken(token: string);
    /**
     * Delete the Portfolio Access Metadata Rule that exactly matches the provided identifier parts
     * @summary [EXPERIMENTAL] 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
     */
    deleteKeyFromPortfolioAccessMetadata(scope: string, code: string, metadataKey: string, effectiveAt?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: DeletedEntityResponse;
    }>;
    /**
     * Delete a single portfolio. The deletion of the portfolio will be valid from the portfolio\'s creation datetime. This means that the portfolio will no longer exist at any effective datetime from the asAt datetime of deletion.
     * @summary Delete portfolio
     * @param scope The scope of the portfolio.
     * @param code The code of 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 single portfolio. If the properties are time variant then an effective date time from which the properties  will be deleted must be specified. If the properties are perpetual then it is invalid to specify an effective date time for deletion.
     * @summary Delete portfolio properties
     * @param scope The scope of the portfolio to delete properties from.
     * @param code The code of the portfolio to delete properties from. Together with the scope this uniquely              identifies the portfolio.
     * @param propertyKeys The property keys of the properties to delete. These take the format              {domain}/{scope}/{code} e.g. \&quot;Portfolio/Manager/Id\&quot;. Each property must be from the \&quot;Portfolio\&quot; domain.
     * @param effectiveAt The effective datetime or cut label at which to delete the properties.
     */
    deletePortfolioProperties(scope: string, code: string, propertyKeys: Array<string>, effectiveAt?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: DeletedEntityResponse;
    }>;
    /**
     * Retrieve the definition of a single portfolio.
     * @summary Get portfolio
     * @param scope The scope of the portfolio to retrieve the definition for.
     * @param code The code of the portfolio to retrieve the definition for. 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 return the latest version of the portfolio definition if not specified.
     * @param propertyKeys A list of property keys from the \&quot;Portfolio\&quot; domain to decorate onto the portfolio.              These take the format {domain}/{scope}/{code} e.g. \&quot;Portfolio/Manager/Id\&quot;.
     */
    getPortfolio(scope: string, code: string, effectiveAt?: string, asAt?: Date, propertyKeys?: Array<string>, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: Portfolio;
    }>;
    /**
     * Gets all the commands that modified a single portfolio, including any input transactions.
     * @summary [EARLY ACCESS] Get portfolio commands
     * @param scope The scope of the portfolio to retrieve the commands for.
     * @param code The code of the portfolio to retrieve the commands for. 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 result set.              For example, to filter on the User ID, use \&quot;userId.id eq \&#39;string\&#39;\&quot;              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
     */
    getPortfolioCommands(scope: string, code: string, fromAsAt?: Date, toAsAt?: Date, filter?: string, 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 [EXPERIMENTAL] 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 single portfolio.
     * @summary Get portfolio properties
     * @param scope The scope of the portfolio to list the properties for.
     * @param code The code of the portfolio to list the properties for. 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 return 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;
    }>;
    /**
     * 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 [EXPERIMENTAL] 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>;
    }>;
    /**
     * List all the portfolios matching the specified criteria.
     * @summary 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 return the latest version              of each portfolio if not specified.
     * @param page The pagination token to use to continue listing portfolios from a previous call to list 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. Also, if set, a start value cannot be provided.
     * @param start When paginating, skip this number of results.
     * @param limit When paginating, limit the number of returned results to this many. Defaults to 65,535 if not specified.
     * @param filter Expression to filter the result set.               For example, to filter on the Type, use \&quot;type eq \&#39;Transaction\&#39;\&quot;              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
     * @param query Expression specifying the criteria that the returned portfolios must meet e.g. to see which              portfolios have holdings in the instruments with a Lusid Instrument Id (LUID) of \&#39;LUID_PPA8HI6M\&#39; or a Figi of \&#39;BBG000BLNNH6\&#39;              you would 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 \&quot;Portfolio\&quot; domain to decorate onto each portfolio.              These take the format {domain}/{scope}/{code} e.g. \&quot;Portfolio/Manager/Id\&quot;.
     */
    listPortfolios(effectiveAt?: string, asAt?: Date, page?: string, start?: number, limit?: number, filter?: string, query?: string, propertyKeys?: Array<string>, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfPortfolio;
    }>;
    /**
     * List all the portfolios in a single scope.
     * @summary List portfolios for scope
     * @param scope The scope of the 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 return the latest version              of each portfolio if not specified.
     * @param page The pagination token to use to continue listing portfolios from a previous call to list 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. Also, if set, a start value cannot be provided.
     * @param start When paginating, skip this number of results.
     * @param limit When paginating, limit the number of returned results to this many. Defaults to 65,535 if not specified.
     * @param filter Expression to filter the result set.              For example, to filter on the Type, use \&quot;type eq \&#39;Transaction\&#39;\&quot;              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.
     * @param propertyKeys A list of property keys from the \&quot;Portfolio\&quot; domain to decorate onto each portfolio.              These take the format {domain}/{scope}/{code} e.g. \&quot;Portfolio/Manager/Id\&quot;.
     */
    listPortfoliosForScope(scope: string, effectiveAt?: string, asAt?: Date, page?: string, start?: number, limit?: number, filter?: string, propertyKeys?: Array<string>, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfPortfolio;
    }>;
    /**
     * Update the definition of a single portfolio. Not all elements within a portfolio definition are  modifiable due to the potential implications for data already stored against the portfolio.
     * @summary Update portfolio
     * @param scope The scope of the portfolio to update the definition for.
     * @param code The code of the portfolio to update the definition for. Together with the scope this uniquely              identifies the portfolio.
     * @param portfolioDefinition 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, portfolioDefinition: UpdatePortfolioRequest, effectiveAt?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: Portfolio;
    }>;
    /**
     * 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 [EXPERIMENTAL] 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 request The Portfolio Access Metadata Rule to update or insert
     * @param effectiveAt The date this rule will effective from
     */
    upsertPortfolioAccessMetadata(scope: string, code: string, metadataKey: string, request: UpsertPortfolioAccessMetadataRequest, effectiveAt?: string, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: ResourceListOfAccessMetadataValueOf;
    }>;
    /**
     * Update or insert one or more properties onto a single portfolio. A property will be updated if it  already exists and inserted if it does not. All properties must be of the domain \'Portfolio\'.
     * @summary Upsert portfolio properties
     * @param scope The scope of the portfolio to update or insert the properties onto.
     * @param code The code of the portfolio to update or insert the properties onto. Together with the scope              this uniquely identifies the portfolio.
     * @param portfolioProperties The properties to be updated or inserted onto the portfolio. Each property in              the request must be keyed by its unique property key. This has the format {domain}/{scope}/{code} e.g. \&quot;Portfolio/Manager/Id\&quot;.
     */
    upsertPortfolioProperties(scope: string, code: string, portfolioProperties: {
        [key: string]: Property;
    }, options?: {
        headers: {
            [name: string]: string;
        };
    }): Promise<{
        response: http.IncomingMessage;
        body: PortfolioProperties;
    }>;
}
