/**
 * A representation of an FDC3 Action (specified via a Context or Context & Intent) that can
 * be inserted inside another object, for example a chat message.
 *
 * The action may be completed by calling `fdc3.raiseIntent()` with the specified Intent and
 * Context, or, if only a context is specified, by calling `fdc3.raiseIntentForContext()`
 * (which the Desktop Agent will resolve by presenting the user with a list of available
 * Intents for the Context).
 *
 * Accepts an optional `app` parameter in order to specify a specific app.
 */
export interface Action {
    /**
     * An optional target application identifier that should perform the action
     */
    app?: ActionTargetApp;
    /**
     * A context object with which the action will be performed
     */
    context: ContextElement;
    /**
     * Optional Intent to raise to perform the actions. Should reference an intent type name,
     * such as those defined in the FDC3 Standard. If intent is not set then
     * `fdc3.raiseIntentForContext` should be used to perform the action as this will usually
     * allow the user to choose the intent to raise.
     */
    intent?: string;
    /**
     * A human readable display name for the action
     */
    title: string;
    type: "fdc3.action";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * An optional target application identifier that should perform the action
 *
 * Identifies an application, or instance of an application, and is used to target FDC3 API
 * calls, such as `fdc3.open` or `fdc3.raiseIntent` at specific applications or application
 * instances.
 *
 * Will always include at least an `appId` field, which uniquely identifies a specific app.
 *
 * If the `instanceId` field is set then the `AppMetadata` object represents a specific
 * instance of the application that may be addressed using that Id.
 */
export interface ActionTargetApp {
    /**
     * The unique application identifier located within a specific application directory
     * instance. An example of an appId might be 'app@sub.root'
     */
    appId: string;
    /**
     * The Desktop Agent that the app is available on. Used in Desktop Agent Bridging to
     * identify the Desktop Agent to target.
     */
    desktopAgent?: string;
    /**
     * An optional instance identifier, indicating that this object represents a specific
     * instance of the application described.
     */
    instanceId?: string;
    [property: string]: any;
}
/**
 * A context object with which the action will be performed
 *
 * A context object returned by the transaction, possibly with updated data.
 *
 * The `fdc3.context` type defines the basic contract or "shape" for all data exchanged by
 * FDC3 operations. As such, it is not really meant to be used on its own, but is imported
 * by more specific type definitions (standardized or custom) to provide the structure and
 * properties shared by all FDC3 context data types.
 *
 * The key element of FDC3 context types is their mandatory `type` property, which is used
 * to identify what type of data the object represents, and what shape it has.
 *
 * The FDC3 context type, and all derived types, define the minimum set of fields a context
 * data object of a particular type can be expected to have, but this can always be extended
 * with custom fields as appropriate.
 */
export interface ContextElement {
    /**
     * Context data objects may include a set of equivalent key-value pairs that can be used to
     * help applications identify and look up the context type they receive in their own domain.
     * The idea behind this design is that applications can provide as many equivalent
     * identifiers to a target application as possible, e.g. an instrument may be represented by
     * an ISIN, CUSIP or Bloomberg identifier.
     *
     * Identifiers do not make sense for all types of data, so the `id` property is therefore
     * optional, but some derived types may choose to require at least one identifier.
     * Identifier values SHOULD always be of type string.
     */
    id?: {
        [key: string]: any;
    };
    /**
     * Context data objects may include a name property that can be used for more information,
     * or display purposes. Some derived types may require the name object as mandatory,
     * depending on use case.
     */
    name?: string;
    /**
     * The type property is the only _required_ part of the FDC3 context data schema. The FDC3
     * [API](https://fdc3.finos.org/docs/api/spec) relies on the `type` property being present
     * to route shared context data appropriately.
     *
     * FDC3 [Intents](https://fdc3.finos.org/docs/intents/spec) also register the context data
     * types they support in an FDC3 [App
     * Directory](https://fdc3.finos.org/docs/app-directory/overview), used for intent discovery
     * and routing.
     *
     * Standardized FDC3 context types have well-known `type` properties prefixed with the
     * `fdc3` namespace, e.g. `fdc3.instrument`. For non-standard types, e.g. those defined and
     * used by a particular organization, the convention is to prefix them with an
     * organization-specific namespace, e.g. `blackrock.fund`.
     *
     * See the [Context Data Specification](https://fdc3.finos.org/docs/context/spec) for more
     * information about context data types.
     */
    type: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A context type representing details of a Chart, which may be used to request plotting of
 * a particular chart or to otherwise share details of its composition, such as:
 *
 * - A list of instruments for comparison
 * - The time period to plot the chart over
 * - The style of chart (line, bar, mountain, candle etc.)
 * - Other settings such as indicators to calculate, or data representing drawings and
 * annotations.
 *
 * In addition to handling requests to plot charts, a charting application may use this type
 * to output a representation of what it is currently displaying so that it can be recorded
 * by another application.
 */
export interface Chart {
    /**
     * An array of instrument contexts whose data should be plotted.
     */
    instruments: InstrumentElement[];
    /**
     * It is common for charts to support other configuration, such as indicators, annotations
     * etc., which do not have standardized formats, but may be included in the `otherConfig`
     * array as context objects.
     */
    otherConfig?: ContextElement[];
    /**
     * The time range that should be plotted
     */
    range?: TimeRangeObject;
    /**
     * The type of chart that should be plotted
     */
    style?: ChartStyle;
    type: "fdc3.chart";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * financial instrument that relates to the definition of this product
 *
 *
 *
 * A financial instrument from any asset class.
 */
export interface InstrumentElement {
    /**
     * Any combination of instrument identifiers can be used together to resolve ambiguity, or
     * for a better match. Not all applications will use the same instrument identifiers, which
     * is why FDC3 allows for multiple to be specified. In general, the more identifiers an
     * application can provide, the easier it will be to achieve interoperability.
     *
     * It is valid to include extra properties and metadata as part of the instrument payload,
     * but the minimum requirement is for at least one instrument identifier to be provided.
     *
     * Try to only use instrument identifiers as intended. E.g. the `ticker` property is meant
     * for tickers as used by an exchange.
     * If the identifier you want to share is not a ticker or one of the other standardized
     * fields, define a property that makes it clear what the value represents. Doing so will
     * make interpretation easier for the developers of target applications.
     */
    id: PurpleInstrumentIdentifiers;
    /**
     * The `market` map can be used to further specify the instrument and help achieve
     * interoperability between disparate data sources. This is especially useful when using an
     * `id` field that is not globally unique.
     */
    market?: OrganizationMarket;
    type: "fdc3.instrument";
    name?: string;
    [property: string]: any;
}
/**
 * Any combination of instrument identifiers can be used together to resolve ambiguity, or
 * for a better match. Not all applications will use the same instrument identifiers, which
 * is why FDC3 allows for multiple to be specified. In general, the more identifiers an
 * application can provide, the easier it will be to achieve interoperability.
 *
 * It is valid to include extra properties and metadata as part of the instrument payload,
 * but the minimum requirement is for at least one instrument identifier to be provided.
 *
 * Try to only use instrument identifiers as intended. E.g. the `ticker` property is meant
 * for tickers as used by an exchange.
 * If the identifier you want to share is not a ticker or one of the other standardized
 * fields, define a property that makes it clear what the value represents. Doing so will
 * make interpretation easier for the developers of target applications.
 */
export interface PurpleInstrumentIdentifiers {
    /**
     * <https://www.bloomberg.com/>
     */
    BBG?: string;
    /**
     * <https://www.cusip.com/>
     */
    CUSIP?: string;
    /**
     * <https://www.factset.com/>
     */
    FDS_ID?: string;
    /**
     * <https://www.openfigi.com/>
     */
    FIGI?: string;
    /**
     * <https://www.isin.org/>
     */
    ISIN?: string;
    /**
     * <https://permid.org/>
     */
    PERMID?: string;
    /**
     * <https://www.refinitiv.com/>
     */
    RIC?: string;
    /**
     * <https://www.lseg.com/sedol>
     */
    SEDOL?: string;
    /**
     * Unstandardized stock tickers
     */
    ticker?: string;
    [property: string]: any;
}
/**
 * The `market` map can be used to further specify the instrument and help achieve
 * interoperability between disparate data sources. This is especially useful when using an
 * `id` field that is not globally unique.
 */
export interface OrganizationMarket {
    /**
     * <https://www.bloomberg.com/>
     */
    BBG?: string;
    /**
     * <https://www.iso.org/iso-3166-country-codes.html>
     */
    COUNTRY_ISOALPHA2?: string;
    /**
     * <https://en.wikipedia.org/wiki/Market_Identifier_Code>
     */
    MIC?: string;
    /**
     * Human readable market name
     */
    name?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * The time range that should be plotted
 *
 * The time range over which the interaction occurred
 *
 * A context representing a period of time. Any user interfaces that represent or visualize
 * events or activity over time can be filtered or focused on a particular time period,
 * e.g.:
 *
 * - A pricing chart
 * - A trade blotter
 * - A record of client contact/activity in a CRM
 *
 * Example use cases:
 *
 * - User may want to view pricing/trades/customer activity for a security over a particular
 * time period, the time range might be specified as the context for the `ViewChart` intent
 * OR it might be embedded in another context (e.g. a context representing a chart to plot).
 * - User filters a visualization (e.g. a pricing chart) to show a particular period, the
 * `TimeRange` is broadcast and other visualizations (e.g. a heatmap of activity by
 * instrument, or industry sector etc.) receive it and filter themselves to show data over
 * the same range.
 *
 * Notes:
 *
 * - A `TimeRange` may be closed (i.e. `startTime` and `endTime` are both known) or open
 * (i.e. only one of `startTime` or `endTime` is known).
 * - Ranges corresponding to dates (e.g. `2022-05-12` to `2022-05-19`) should be specified
 * using times as this prevents issues with timezone conversions and inclusive/exclusive
 * date ranges.
 * - String fields representing times are encoded according to [ISO
 * 8601-1:2019](https://www.iso.org/standard/70907.html).
 * - A timezone indicator should be specified, e.g. `"2022-05-12T15:18:03Z"` or
 * `"2022-05-12T16:18:03+01:00"`
 * - Times MAY be specified with millisecond precision, e.g. `"2022-05-12T15:18:03.349Z"`
 */
export interface TimeRangeObject {
    /**
     * The end time of the range, encoded according to [ISO
     * 8601-1:2019](https://www.iso.org/standard/70907.html) with a timezone indicator.
     */
    endTime?: Date;
    /**
     * The start time of the range, encoded according to [ISO
     * 8601-1:2019](https://www.iso.org/standard/70907.html) with a timezone indicator.
     */
    startTime?: Date;
    type: "fdc3.timerange";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * The type of chart that should be plotted
 */
export type ChartStyle = "line" | "bar" | "stacked-bar" | "mountain" | "candle" | "pie" | "scatter" | "histogram" | "heatmap" | "custom";
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A collection of settings to start a new chat conversation
 */
export interface ChatInitSettings {
    /**
     * Name to apply to the chat created
     */
    chatName?: string;
    /**
     * Contacts to add to the chat
     */
    members?: ContactListObject;
    /**
     * An initial message to post in the chat when created.
     */
    message?: MessageObject | string;
    /**
     * Option settings that affect the creation of the chat
     */
    options?: ChatOptions;
    type: "fdc3.chat.initSettings";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * Contacts to add to the chat
 *
 * A list of contacts involved in the interaction
 *
 * A collection of contacts, e.g. for chatting to or calling multiple contacts.
 *
 * The contact list schema does not explicitly include identifiers in the `id` section, as
 * there is not a common standard for such identifiers. Applications can, however, populate
 * this part of the contract with custom identifiers if so desired.
 */
export interface ContactListObject {
    /**
     * An array of contact contexts that forms the list.
     */
    contacts: ContactElement[];
    type: "fdc3.contactList";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * The contact that initiated the interaction
 *
 * A person contact that can be engaged with through email, calling, messaging, CMS, etc.
 */
export interface ContactElement {
    /**
     * Identifiers that relate to the Contact represented by this context
     */
    id: PurpleContactIdentifiers;
    type: "fdc3.contact";
    name?: string;
    [property: string]: any;
}
/**
 * Identifiers that relate to the Contact represented by this context
 */
export interface PurpleContactIdentifiers {
    /**
     * The email address for the contact
     */
    email?: string;
    /**
     * FactSet Permanent Identifier representing the contact
     */
    FDS_ID?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A chat message to be sent through an instant messaging application. Can contain one or
 * several text bodies (organized by mime-type, plaintext or markdown), as well as attached
 * entities (either arbitrary file attachments or FDC3 actions to be embedded in the
 * message). To be put inside a ChatInitSettings object.
 */
export interface MessageObject {
    /**
     * A map of string IDs to entities that should be attached to the message, such as an action
     * to perform, a file attachment, or other FDC3 context object.
     */
    entities?: {
        [key: string]: PurpleAction;
    };
    /**
     * A map of string mime-type to string content
     */
    text?: PurpleMessageText;
    type: "fdc3.message";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * A representation of an FDC3 Action (specified via a Context or Context & Intent) that can
 * be inserted inside another object, for example a chat message.
 *
 * The action may be completed by calling `fdc3.raiseIntent()` with the specified Intent and
 * Context, or, if only a context is specified, by calling `fdc3.raiseIntentForContext()`
 * (which the Desktop Agent will resolve by presenting the user with a list of available
 * Intents for the Context).
 *
 * Accepts an optional `app` parameter in order to specify a specific app.
 *
 * A File attachment encoded in the form of a data URI
 */
export interface PurpleAction {
    /**
     * An optional target application identifier that should perform the action
     */
    app?: ActionTargetApp;
    /**
     * A context object with which the action will be performed
     */
    context?: ContextElement;
    /**
     * Optional Intent to raise to perform the actions. Should reference an intent type name,
     * such as those defined in the FDC3 Standard. If intent is not set then
     * `fdc3.raiseIntentForContext` should be used to perform the action as this will usually
     * allow the user to choose the intent to raise.
     */
    intent?: string;
    /**
     * A human readable display name for the action
     */
    title?: string;
    type: EntityType;
    id?: {
        [key: string]: any;
    };
    name?: string;
    data?: PurpleData;
    [property: string]: any;
}
export interface PurpleData {
    /**
     * A data URI encoding the content of the file to be attached
     */
    dataUri: string;
    /**
     * The name of the attached file
     */
    name: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
export type EntityType = "fdc3.action" | "fdc3.entity.fileAttachment";
/**
 * A map of string mime-type to string content
 */
export interface PurpleMessageText {
    /**
     * Markdown encoded content
     */
    "text/markdown"?: string;
    /**
     * Plain text encoded content.
     */
    "text/plain"?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * Option settings that affect the creation of the chat
 */
export interface ChatOptions {
    /**
     * if true members will be allowed to add other members to the chat
     */
    allowAddUser?: boolean;
    /**
     * if true members will be allowed to browse past messages
     */
    allowHistoryBrowsing?: boolean;
    /**
     * if true members will be allowed to copy/paste messages
     */
    allowMessageCopy?: boolean;
    /**
     * if false a separate chat will be created for each member
     */
    groupRecipients?: boolean;
    /**
     * if true the room will be visible to everyone in the chat application
     */
    isPublic?: boolean;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A context representing a chat message. Typically used to send the message or to
 * pre-populate a message for sending.
 */
export interface ChatMessage {
    chatRoom: ChatRoomObject;
    message: MessageObject;
    type: "fdc3.chat.message";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * Reference to the chat room which could be used to send a message to the room
 */
export interface ChatRoomObject {
    /**
     * Identifier(s) for the chat - currently unstandardized
     */
    id: {
        [key: string]: any;
    };
    /**
     * Display name for the chat room
     */
    name?: string;
    /**
     * The name of the service that hosts the chat
     */
    providerName: string;
    type: "fdc3.chat.room";
    /**
     * Universal url to access to the room. It could be opened from a browser, a mobile app,
     * etc...
     */
    url?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * Reference to the chat room which could be used to send a message to the room
 */
export interface ChatRoom {
    /**
     * Identifier(s) for the chat - currently unstandardized
     */
    id: {
        [key: string]: any;
    };
    /**
     * Display name for the chat room
     */
    name?: string;
    /**
     * The name of the service that hosts the chat
     */
    providerName: string;
    type: "fdc3.chat.room";
    /**
     * Universal url to access to the room. It could be opened from a browser, a mobile app,
     * etc...
     */
    url?: string;
    [property: string]: any;
}
/**
 * A context type that represents a simple search criterion, based on a list of other
 * context objects, that can be used to search or filter messages in a chat application.
 */
export interface ChatSearchCriteria {
    /**
     * An array of criteria that should match chats returned from by a search.
     *
     * ⚠️ Operators (and/or/not) are not defined in `fdc3.chat.searchCriteria`. It is up to the
     * application that processes the FDC3 Intent to choose and apply the operators between the
     * criteria.
     *
     * Empty search criteria can be supported to allow resetting of filters.
     */
    criteria: Array<OrganizationObject | string>;
    type: "fdc3.chat.searchCriteria";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * financial instrument that relates to the definition of this product
 *
 *
 *
 * A financial instrument from any asset class.
 *
 * An entity that can be used when referencing private companies and other organizations
 * where a specific instrument is not available or desired e.g. CRM and News workflows.
 *
 * It is valid to include extra properties and metadata as part of the organization payload,
 * but the minimum requirement is for at least one specified identifier to be provided.
 *
 * The contact that initiated the interaction
 *
 * A person contact that can be engaged with through email, calling, messaging, CMS, etc.
 */
export interface OrganizationObject {
    /**
     * Any combination of instrument identifiers can be used together to resolve ambiguity, or
     * for a better match. Not all applications will use the same instrument identifiers, which
     * is why FDC3 allows for multiple to be specified. In general, the more identifiers an
     * application can provide, the easier it will be to achieve interoperability.
     *
     * It is valid to include extra properties and metadata as part of the instrument payload,
     * but the minimum requirement is for at least one instrument identifier to be provided.
     *
     * Try to only use instrument identifiers as intended. E.g. the `ticker` property is meant
     * for tickers as used by an exchange.
     * If the identifier you want to share is not a ticker or one of the other standardized
     * fields, define a property that makes it clear what the value represents. Doing so will
     * make interpretation easier for the developers of target applications.
     *
     * Identifiers for the organization, at least one must be provided.
     *
     * Identifiers that relate to the Contact represented by this context
     */
    id: Identifiers;
    /**
     * The `market` map can be used to further specify the instrument and help achieve
     * interoperability between disparate data sources. This is especially useful when using an
     * `id` field that is not globally unique.
     */
    market?: OrganizationMarket;
    type: TentacledInteractionType;
    name?: string;
    [property: string]: any;
}
/**
 * Any combination of instrument identifiers can be used together to resolve ambiguity, or
 * for a better match. Not all applications will use the same instrument identifiers, which
 * is why FDC3 allows for multiple to be specified. In general, the more identifiers an
 * application can provide, the easier it will be to achieve interoperability.
 *
 * It is valid to include extra properties and metadata as part of the instrument payload,
 * but the minimum requirement is for at least one instrument identifier to be provided.
 *
 * Try to only use instrument identifiers as intended. E.g. the `ticker` property is meant
 * for tickers as used by an exchange.
 * If the identifier you want to share is not a ticker or one of the other standardized
 * fields, define a property that makes it clear what the value represents. Doing so will
 * make interpretation easier for the developers of target applications.
 *
 * Identifiers for the organization, at least one must be provided.
 *
 * Identifiers that relate to the Contact represented by this context
 */
export interface Identifiers {
    /**
     * <https://www.bloomberg.com/>
     */
    BBG?: string;
    /**
     * <https://www.cusip.com/>
     */
    CUSIP?: string;
    /**
     * <https://www.factset.com/>
     *
     * FactSet Permanent Identifier representing the organization
     *
     * FactSet Permanent Identifier representing the contact
     */
    FDS_ID?: string;
    /**
     * <https://www.openfigi.com/>
     */
    FIGI?: string;
    /**
     * <https://www.isin.org/>
     */
    ISIN?: string;
    /**
     * <https://permid.org/>
     *
     * Refinitiv Permanent Identifiers, or PermID for the organization
     */
    PERMID?: string;
    /**
     * <https://www.refinitiv.com/>
     */
    RIC?: string;
    /**
     * <https://www.lseg.com/sedol>
     */
    SEDOL?: string;
    /**
     * Unstandardized stock tickers
     */
    ticker?: string;
    /**
     * The Legal Entity Identifier (LEI) is a 20-character, alpha-numeric code based on the ISO
     * 17442 standard developed by the International Organization for Standardization (ISO). It
     * connects to key reference information that enables clear and unique identification of
     * legal entities participating in financial transactions.
     */
    LEI?: string;
    /**
     * The email address for the contact
     */
    email?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
export type TentacledInteractionType = "fdc3.instrument" | "fdc3.organization" | "fdc3.contact";
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A person contact that can be engaged with through email, calling, messaging, CMS, etc.
 */
export interface Contact {
    /**
     * Identifiers that relate to the Contact represented by this context
     */
    id: FluffyContactIdentifiers;
    type: "fdc3.contact";
    name?: string;
    [property: string]: any;
}
/**
 * Identifiers that relate to the Contact represented by this context
 */
export interface FluffyContactIdentifiers {
    /**
     * The email address for the contact
     */
    email?: string;
    /**
     * FactSet Permanent Identifier representing the contact
     */
    FDS_ID?: string;
    [property: string]: any;
}
/**
 * A collection of contacts, e.g. for chatting to or calling multiple contacts.
 *
 * The contact list schema does not explicitly include identifiers in the `id` section, as
 * there is not a common standard for such identifiers. Applications can, however, populate
 * this part of the contract with custom identifiers if so desired.
 */
export interface ContactList {
    /**
     * An array of contact contexts that forms the list.
     */
    contacts: ContactElement[];
    type: "fdc3.contactList";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * The `fdc3.context` type defines the basic contract or "shape" for all data exchanged by
 * FDC3 operations. As such, it is not really meant to be used on its own, but is imported
 * by more specific type definitions (standardized or custom) to provide the structure and
 * properties shared by all FDC3 context data types.
 *
 * The key element of FDC3 context types is their mandatory `type` property, which is used
 * to identify what type of data the object represents, and what shape it has.
 *
 * The FDC3 context type, and all derived types, define the minimum set of fields a context
 * data object of a particular type can be expected to have, but this can always be extended
 * with custom fields as appropriate.
 */
export interface Context {
    /**
     * Context data objects may include a set of equivalent key-value pairs that can be used to
     * help applications identify and look up the context type they receive in their own domain.
     * The idea behind this design is that applications can provide as many equivalent
     * identifiers to a target application as possible, e.g. an instrument may be represented by
     * an ISIN, CUSIP or Bloomberg identifier.
     *
     * Identifiers do not make sense for all types of data, so the `id` property is therefore
     * optional, but some derived types may choose to require at least one identifier.
     * Identifier values SHOULD always be of type string.
     */
    id?: {
        [key: string]: any;
    };
    /**
     * Context data objects may include a name property that can be used for more information,
     * or display purposes. Some derived types may require the name object as mandatory,
     * depending on use case.
     */
    name?: string;
    /**
     * The type property is the only _required_ part of the FDC3 context data schema. The FDC3
     * [API](https://fdc3.finos.org/docs/api/spec) relies on the `type` property being present
     * to route shared context data appropriately.
     *
     * FDC3 [Intents](https://fdc3.finos.org/docs/intents/spec) also register the context data
     * types they support in an FDC3 [App
     * Directory](https://fdc3.finos.org/docs/app-directory/overview), used for intent discovery
     * and routing.
     *
     * Standardized FDC3 context types have well-known `type` properties prefixed with the
     * `fdc3` namespace, e.g. `fdc3.instrument`. For non-standard types, e.g. those defined and
     * used by a particular organization, the convention is to prefix them with an
     * organization-specific namespace, e.g. `blackrock.fund`.
     *
     * See the [Context Data Specification](https://fdc3.finos.org/docs/context/spec) for more
     * information about context data types.
     */
    type: string;
    [property: string]: any;
}
/**
 * A country entity.
 *
 * Notes:
 *
 * - It is valid to include extra properties and metadata as part of the country payload,
 * but the minimum requirement is for at least one standardized identifier to be provided
 *
 * - `COUNTRY_ISOALPHA2` SHOULD be preferred.
 *
 * - Try to only use country identifiers as intended and specified in the [ISO
 * standard](https://en.wikipedia.org/wiki/ISO_3166-1). E.g. the `COUNTRY_ISOALPHA2`
 * property must be a recognized value and not a proprietary two-letter code. If the
 * identifier you want to share is not a standardized and recognized one, rather define a
 * property that makes it clear what value it is. This makes it easier for target
 * applications.
 */
export interface Country {
    id: CountryID;
    type: "fdc3.country";
    name?: string;
    [property: string]: any;
}
export interface CountryID {
    /**
     * Two-letter ISO country code
     */
    COUNTRY_ISOALPHA2?: string;
    /**
     * Three-letter ISO country code
     */
    COUNTRY_ISOALPHA3?: string;
    /**
     * Two-letter ISO country code. Deprecated in FDC3 2.0 in favour of the version prefixed
     * with `COUNTRY_`.
     */
    ISOALPHA2?: string;
    /**
     * Three-letter ISO country code. Deprecated in FDC3 2.0 in favour of the version prefixed
     * with `COUNTRY_`.
     */
    ISOALPHA3?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A context representing an individual Currency.
 */
export interface Currency {
    id: CurrencyID;
    /**
     * The name of the currency for display purposes
     */
    name?: string;
    type: "fdc3.currency";
    [property: string]: any;
}
export interface CurrencyID {
    /**
     * The `CURRENCY_ISOCODE` should conform to 3 character alphabetic codes defined in [ISO
     * 4217](https://www.iso.org/iso-4217-currency-codes.html)
     */
    CURRENCY_ISOCODE?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A collection of information to be used to initiate an email with a Contact or ContactList.
 */
export interface Email {
    /**
     * One or more receipients for the email.
     */
    recipients: EmailRecipients;
    /**
     * Subject line for the email.
     */
    subject?: string;
    /**
     * Body content for the email.
     */
    textBody?: string;
    type: "fdc3.email";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * One or more receipients for the email.
 *
 * The contact that initiated the interaction
 *
 * A person contact that can be engaged with through email, calling, messaging, CMS, etc.
 *
 * Contacts to add to the chat
 *
 * A list of contacts involved in the interaction
 *
 * A collection of contacts, e.g. for chatting to or calling multiple contacts.
 *
 * The contact list schema does not explicitly include identifiers in the `id` section, as
 * there is not a common standard for such identifiers. Applications can, however, populate
 * this part of the contract with custom identifiers if so desired.
 */
export interface EmailRecipients {
    /**
     * Identifiers that relate to the Contact represented by this context
     */
    id?: EmailRecipientsID;
    type: EmailRecipientsType;
    name?: string;
    /**
     * An array of contact contexts that forms the list.
     */
    contacts?: ContactElement[];
    [property: string]: any;
}
/**
 * Identifiers that relate to the Contact represented by this context
 */
export interface EmailRecipientsID {
    /**
     * The email address for the contact
     */
    email?: string;
    /**
     * FactSet Permanent Identifier representing the contact
     */
    FDS_ID?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
export type EmailRecipientsType = "fdc3.contact" | "fdc3.contactList";
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A financial instrument from any asset class.
 */
export interface Instrument {
    /**
     * Any combination of instrument identifiers can be used together to resolve ambiguity, or
     * for a better match. Not all applications will use the same instrument identifiers, which
     * is why FDC3 allows for multiple to be specified. In general, the more identifiers an
     * application can provide, the easier it will be to achieve interoperability.
     *
     * It is valid to include extra properties and metadata as part of the instrument payload,
     * but the minimum requirement is for at least one instrument identifier to be provided.
     *
     * Try to only use instrument identifiers as intended. E.g. the `ticker` property is meant
     * for tickers as used by an exchange.
     * If the identifier you want to share is not a ticker or one of the other standardized
     * fields, define a property that makes it clear what the value represents. Doing so will
     * make interpretation easier for the developers of target applications.
     */
    id: FluffyInstrumentIdentifiers;
    /**
     * The `market` map can be used to further specify the instrument and help achieve
     * interoperability between disparate data sources. This is especially useful when using an
     * `id` field that is not globally unique.
     */
    market?: PurpleMarket;
    type: "fdc3.instrument";
    name?: string;
    [property: string]: any;
}
/**
 * Any combination of instrument identifiers can be used together to resolve ambiguity, or
 * for a better match. Not all applications will use the same instrument identifiers, which
 * is why FDC3 allows for multiple to be specified. In general, the more identifiers an
 * application can provide, the easier it will be to achieve interoperability.
 *
 * It is valid to include extra properties and metadata as part of the instrument payload,
 * but the minimum requirement is for at least one instrument identifier to be provided.
 *
 * Try to only use instrument identifiers as intended. E.g. the `ticker` property is meant
 * for tickers as used by an exchange.
 * If the identifier you want to share is not a ticker or one of the other standardized
 * fields, define a property that makes it clear what the value represents. Doing so will
 * make interpretation easier for the developers of target applications.
 */
export interface FluffyInstrumentIdentifiers {
    /**
     * <https://www.bloomberg.com/>
     */
    BBG?: string;
    /**
     * <https://www.cusip.com/>
     */
    CUSIP?: string;
    /**
     * <https://www.factset.com/>
     */
    FDS_ID?: string;
    /**
     * <https://www.openfigi.com/>
     */
    FIGI?: string;
    /**
     * <https://www.isin.org/>
     */
    ISIN?: string;
    /**
     * <https://permid.org/>
     */
    PERMID?: string;
    /**
     * <https://www.refinitiv.com/>
     */
    RIC?: string;
    /**
     * <https://www.lseg.com/sedol>
     */
    SEDOL?: string;
    /**
     * Unstandardized stock tickers
     */
    ticker?: string;
    [property: string]: any;
}
/**
 * The `market` map can be used to further specify the instrument and help achieve
 * interoperability between disparate data sources. This is especially useful when using an
 * `id` field that is not globally unique.
 */
export interface PurpleMarket {
    /**
     * <https://www.bloomberg.com/>
     */
    BBG?: string;
    /**
     * <https://www.iso.org/iso-3166-country-codes.html>
     */
    COUNTRY_ISOALPHA2?: string;
    /**
     * <https://en.wikipedia.org/wiki/Market_Identifier_Code>
     */
    MIC?: string;
    /**
     * Human readable market name
     */
    name?: string;
    [property: string]: any;
}
/**
 * A collection of instruments. Use this type for use cases that require not just a single
 * instrument, but multiple (e.g. to populate a watchlist). However, when holding
 * information for each instrument is required, it is recommended to use the
 * [Portfolio](Portfolio) type.
 *
 * The instrument list schema does not explicitly include identifiers in the `id` section,
 * as there is not a common standard for such identifiers. Applications can, however,
 * populate this part of the contract with custom identifiers if so desired.
 */
export interface InstrumentList {
    /**
     * An array of instrument contexts that forms the list.
     */
    instruments: InstrumentElement[];
    type: "fdc3.instrumentList";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * An `Interaction` is a significant direct exchange of ideas or information between a
 * number of participants, e.g. a Sell Side party and one or more Buy Side parties. An
 * `Interaction` might be a call, a meeting (physical or virtual), an IM or the preparation
 * of some specialist data, such as financial data for a given company or sector.
 */
export interface Interaction {
    /**
     * A human-readable description of the interaction
     */
    description: string;
    /**
     * Can be used by a target application to pass an identifier back to the originating
     * application after an interaction record has been created, updated or deleted. An
     * interaction ID does not need to be populated by the originating application, however the
     * target application could store it for future reference and SHOULD return it in a
     * `TransactionResult`.
     */
    id?: InteractionID;
    /**
     * The contact that initiated the interaction
     */
    initiator?: ContactElement;
    /**
     * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
     * `'Meeting'` although other string values are permitted.
     */
    interactionType: string;
    /**
     * Used to represent the application or service that the interaction was created from to aid
     * in tracing the source of an interaction.
     */
    origin?: string;
    /**
     * A list of contacts involved in the interaction
     */
    participants: ContactListObject;
    /**
     * The time range over which the interaction occurred
     */
    timeRange: TimeRangeObject;
    type: "fdc3.interaction";
    name?: string;
    [property: string]: any;
}
/**
 * Can be used by a target application to pass an identifier back to the originating
 * application after an interaction record has been created, updated or deleted. An
 * interaction ID does not need to be populated by the originating application, however the
 * target application could store it for future reference and SHOULD return it in a
 * `TransactionResult`.
 */
export interface InteractionID {
    /**
     * Interactions ID in Salesforce
     */
    SALESFORCE?: string;
    /**
     * Interaction ID in SingleTrack
     */
    SINGLETRACK?: string;
    /**
     * Can be used by a target application to pass a record's link back to the originating
     * application. This offers the originating application a way to open the record for a user
     * to view.
     */
    URI?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A chat message to be sent through an instant messaging application. Can contain one or
 * several text bodies (organized by mime-type, plaintext or markdown), as well as attached
 * entities (either arbitrary file attachments or FDC3 actions to be embedded in the
 * message). To be put inside a ChatInitSettings object.
 */
export interface Message {
    /**
     * A map of string IDs to entities that should be attached to the message, such as an action
     * to perform, a file attachment, or other FDC3 context object.
     */
    entities?: {
        [key: string]: FluffyAction;
    };
    /**
     * A map of string mime-type to string content
     */
    text?: FluffyMessageText;
    type: "fdc3.message";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * A representation of an FDC3 Action (specified via a Context or Context & Intent) that can
 * be inserted inside another object, for example a chat message.
 *
 * The action may be completed by calling `fdc3.raiseIntent()` with the specified Intent and
 * Context, or, if only a context is specified, by calling `fdc3.raiseIntentForContext()`
 * (which the Desktop Agent will resolve by presenting the user with a list of available
 * Intents for the Context).
 *
 * Accepts an optional `app` parameter in order to specify a specific app.
 *
 * A File attachment encoded in the form of a data URI
 */
export interface FluffyAction {
    /**
     * An optional target application identifier that should perform the action
     */
    app?: ActionTargetApp;
    /**
     * A context object with which the action will be performed
     */
    context?: ContextElement;
    /**
     * Optional Intent to raise to perform the actions. Should reference an intent type name,
     * such as those defined in the FDC3 Standard. If intent is not set then
     * `fdc3.raiseIntentForContext` should be used to perform the action as this will usually
     * allow the user to choose the intent to raise.
     */
    intent?: string;
    /**
     * A human readable display name for the action
     */
    title?: string;
    type: EntityType;
    id?: {
        [key: string]: any;
    };
    name?: string;
    data?: FluffyData;
    [property: string]: any;
}
export interface FluffyData {
    /**
     * A data URI encoding the content of the file to be attached
     */
    dataUri: string;
    /**
     * The name of the attached file
     */
    name: string;
    [property: string]: any;
}
/**
 * A map of string mime-type to string content
 */
export interface FluffyMessageText {
    /**
     * Markdown encoded content
     */
    "text/markdown"?: string;
    /**
     * Plain text encoded content.
     */
    "text/plain"?: string;
    [property: string]: any;
}
/**
 * A type that explicitly represents a lack of context.
 *
 * Notes:
 *
 * - Intended to be used in situations where no context is desired.
 * - For example:
 * - Raising an intent without context (e.g. opening a blank order form, or chat interface
 * without a contact selected).
 * - Resetting context on a channel (e.g. when context is used to set a filter in other
 * applications a null context might release the filter).
 * - An explicit representation of a Null or empty context allows apps to declare support
 * for a lack of context, for example in their intent metadata in an app directory.
 */
export interface Nothing {
    type: "fdc3.nothing";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * @experimental context type representing an order. To be used with OMS and EMS systems.
 *
 * This type currently only defines a required `id` field, which should provide a reference
 * to the order in one or more systems, an optional human readable `name` field to be used
 * to summarize the order and an optional `details` field that may be used to provide
 * additional detail about the order, including a context representing a `product`, which
 * may be extended with arbitrary properties. The `details.product` field is currently typed
 * as a unspecified Context type, but both `details` and `details.product` are expected to
 * be standardized in future.
 */
export interface Order {
    /**
     * Optional additional details about the order, which may include a product element that is
     * an, as yet undefined but extensible, Context
     */
    details?: PurpleOrderDetails;
    /**
     * One or more identifiers that refer to the order in an OMS, EMS or related system.
     * Specific key names for systems are expected to be standardized in future.
     */
    id: {
        [key: string]: string;
    };
    /**
     * An optional human-readable summary of the order.
     */
    name?: string;
    type: "fdc3.order";
    [property: string]: any;
}
/**
 * Optional additional details about the order, which may include a product element that is
 * an, as yet undefined but extensible, Context
 */
export interface PurpleOrderDetails {
    product?: ProductObject;
    [property: string]: any;
}
/**
 * A product that is the subject of the trade.
 *
 * @experimental context type representing a tradable product. To be used with OMS and EMS
 * systems.
 *
 * This type is currently only loosely defined as an extensible context object, with an
 * optional instrument field.
 *
 * The Product schema does not explicitly include identifiers in the id section, as there is
 * not a common standard for such identifiers. Applications can, however, populate this part
 * of the contract with custom identifiers if so desired.
 */
export interface ProductObject {
    /**
     * One or more identifiers that refer to the product. Specific key names for systems are
     * expected to be standardized in future.
     */
    id: {
        [key: string]: string;
    };
    /**
     * financial instrument that relates to the definition of this product
     */
    instrument?: InstrumentElement;
    /**
     * A human-readable summary of the product.
     */
    name?: string;
    type: "fdc3.product";
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * @experimental A list of orders. Use this type for use cases that require not just a
 * single order, but multiple.
 *
 * The OrderList schema does not explicitly include identifiers in the id section, as there
 * is not a common standard for such identifiers. Applications can, however, populate this
 * part of the contract with custom identifiers if so desired.
 */
export interface OrderList {
    /**
     * An array of order contexts that forms the list.
     */
    orders: OrderElement[];
    type: "fdc3.orderList";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * @experimental context type representing an order. To be used with OMS and EMS systems.
 *
 * This type currently only defines a required `id` field, which should provide a reference
 * to the order in one or more systems, an optional human readable `name` field to be used
 * to summarize the order and an optional `details` field that may be used to provide
 * additional detail about the order, including a context representing a `product`, which
 * may be extended with arbitrary properties. The `details.product` field is currently typed
 * as a unspecified Context type, but both `details` and `details.product` are expected to
 * be standardized in future.
 */
export interface OrderElement {
    /**
     * Optional additional details about the order, which may include a product element that is
     * an, as yet undefined but extensible, Context
     */
    details?: FluffyOrderDetails;
    /**
     * One or more identifiers that refer to the order in an OMS, EMS or related system.
     * Specific key names for systems are expected to be standardized in future.
     */
    id: {
        [key: string]: string;
    };
    /**
     * An optional human-readable summary of the order.
     */
    name?: string;
    type: "fdc3.order";
    [property: string]: any;
}
/**
 * Optional additional details about the order, which may include a product element that is
 * an, as yet undefined but extensible, Context
 */
export interface FluffyOrderDetails {
    product?: ProductObject;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * An entity that can be used when referencing private companies and other organizations
 * where a specific instrument is not available or desired e.g. CRM and News workflows.
 *
 * It is valid to include extra properties and metadata as part of the organization payload,
 * but the minimum requirement is for at least one specified identifier to be provided.
 */
export interface Organization {
    /**
     * Identifiers for the organization, at least one must be provided.
     */
    id: OrganizationIdentifiers;
    type: "fdc3.organization";
    name?: string;
    [property: string]: any;
}
/**
 * Identifiers for the organization, at least one must be provided.
 */
export interface OrganizationIdentifiers {
    /**
     * FactSet Permanent Identifier representing the organization
     */
    FDS_ID?: string;
    /**
     * The Legal Entity Identifier (LEI) is a 20-character, alpha-numeric code based on the ISO
     * 17442 standard developed by the International Organization for Standardization (ISO). It
     * connects to key reference information that enables clear and unique identification of
     * legal entities participating in financial transactions.
     */
    LEI?: string;
    /**
     * Refinitiv Permanent Identifiers, or PermID for the organization
     */
    PERMID?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A financial portfolio made up of multiple positions (holdings) in several instruments.
 * Contrast this with e.g. the [InstrumentList](InstrumentList) type, which is just a list
 * of instruments.
 *
 * This is a good example of how types can be composed and extended with extra properties to
 * define more complex types.
 *
 * The Portfolio type consists of an array of [Position](Position) types, each of which
 * refers to a single [Instrument](Instrument) and a holding amount for that instrument.
 *
 * The portfolio schema does not explicitly include identifiers in the `id` section, as
 * there bis not a common standard for such identifiers. Applications can, however, populate
 * this part of the contract with custom identifiers if so desired.
 */
export interface Portfolio {
    /**
     * The List of Positions which make up the Portfolio
     */
    positions: PositionElement[];
    type: "fdc3.portfolio";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * A financial position made up of an instrument and a holding in that instrument. This type
 * is a good example of how new context types can be composed from existing types.
 *
 * In this case, the instrument and the holding amount for that instrument are required
 * values.
 *
 * The [Position](Position) type goes hand-in-hand with the [Portfolio](Portfolio) type,
 * which represents multiple holdings in a combination of instruments.
 *
 * The position schema does not explicitly include identifiers in the `id` section, as there
 * is not a common standard for such identifiers. Applications can, however, populate this
 * part of the contract with custom identifiers if so desired.
 */
export interface PositionElement {
    /**
     * The amount of the holding, e.g. a number of shares
     */
    holding: number;
    instrument: InstrumentElement;
    type: "fdc3.position";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A financial position made up of an instrument and a holding in that instrument. This type
 * is a good example of how new context types can be composed from existing types.
 *
 * In this case, the instrument and the holding amount for that instrument are required
 * values.
 *
 * The [Position](Position) type goes hand-in-hand with the [Portfolio](Portfolio) type,
 * which represents multiple holdings in a combination of instruments.
 *
 * The position schema does not explicitly include identifiers in the `id` section, as there
 * is not a common standard for such identifiers. Applications can, however, populate this
 * part of the contract with custom identifiers if so desired.
 */
export interface Position {
    /**
     * The amount of the holding, e.g. a number of shares
     */
    holding: number;
    instrument: InstrumentElement;
    type: "fdc3.position";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * @experimental context type representing a tradable product. To be used with OMS and EMS
 * systems.
 *
 * This type is currently only loosely defined as an extensible context object, with an
 * optional instrument field.
 *
 * The Product schema does not explicitly include identifiers in the id section, as there is
 * not a common standard for such identifiers. Applications can, however, populate this part
 * of the contract with custom identifiers if so desired.
 */
export interface Product {
    /**
     * One or more identifiers that refer to the product. Specific key names for systems are
     * expected to be standardized in future.
     */
    id: {
        [key: string]: string;
    };
    /**
     * financial instrument that relates to the definition of this product
     */
    instrument?: InstrumentElement;
    /**
     * A human-readable summary of the product.
     */
    name?: string;
    type: "fdc3.product";
    [property: string]: any;
}
/**
 * A context representing a period of time. Any user interfaces that represent or visualize
 * events or activity over time can be filtered or focused on a particular time period,
 * e.g.:
 *
 * - A pricing chart
 * - A trade blotter
 * - A record of client contact/activity in a CRM
 *
 * Example use cases:
 *
 * - User may want to view pricing/trades/customer activity for a security over a particular
 * time period, the time range might be specified as the context for the `ViewChart` intent
 * OR it might be embedded in another context (e.g. a context representing a chart to plot).
 * - User filters a visualization (e.g. a pricing chart) to show a particular period, the
 * `TimeRange` is broadcast and other visualizations (e.g. a heatmap of activity by
 * instrument, or industry sector etc.) receive it and filter themselves to show data over
 * the same range.
 *
 * Notes:
 *
 * - A `TimeRange` may be closed (i.e. `startTime` and `endTime` are both known) or open
 * (i.e. only one of `startTime` or `endTime` is known).
 * - Ranges corresponding to dates (e.g. `2022-05-12` to `2022-05-19`) should be specified
 * using times as this prevents issues with timezone conversions and inclusive/exclusive
 * date ranges.
 * - String fields representing times are encoded according to [ISO
 * 8601-1:2019](https://www.iso.org/standard/70907.html).
 * - A timezone indicator should be specified, e.g. `"2022-05-12T15:18:03Z"` or
 * `"2022-05-12T16:18:03+01:00"`
 * - Times MAY be specified with millisecond precision, e.g. `"2022-05-12T15:18:03.349Z"`
 */
export interface TimeRange {
    /**
     * The end time of the range, encoded according to [ISO
     * 8601-1:2019](https://www.iso.org/standard/70907.html) with a timezone indicator.
     */
    endTime?: Date;
    /**
     * The start time of the range, encoded according to [ISO
     * 8601-1:2019](https://www.iso.org/standard/70907.html) with a timezone indicator.
     */
    startTime?: Date;
    type: "fdc3.timerange";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * @experimental context type representing a trade. To be used with execution systems.
 *
 * This type currently only defines a required `id` field, which should provide a reference
 * to the trade in one or more systems, an optional human readable `name` field to be used
 * to summarize the trade and a required `product` field that may be used to provide
 * additional detail about the trade, which is currently typed as a unspecified Context
 * type, but `product` is expected to be standardized in future.
 *
 * The Trade schema does not explicitly include identifiers in the id section, as there is
 * not a common standard for such identifiers. Applications can, however, populate this part
 * of the contract with custom identifiers if so desired.
 */
export interface Trade {
    /**
     * One or more identifiers that refer to the trade in an OMS, EMS or related system.
     * Specific key names for systems are expected to be standardized in future.
     */
    id: {
        [key: string]: string;
    };
    /**
     * A human-readable summary of the trade.
     */
    name?: string;
    /**
     * A product that is the subject of the trade.
     */
    product: ProductObject;
    type: "fdc3.trade";
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * @experimental A list of trades. Use this type for use cases that require not just a
 * single trade, but multiple.
 *
 * The TradeList schema does not explicitly include identifiers in the id section, as there
 * is not a common standard for such identifiers. Applications can, however, populate this
 * part of the contract with custom identifiers if so desired.
 */
export interface TradeList {
    /**
     * An array of trade contexts that forms the list.
     */
    trades: TradeElement[];
    type: "fdc3.tradeList";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * @experimental context type representing a trade. To be used with execution systems.
 *
 * This type currently only defines a required `id` field, which should provide a reference
 * to the trade in one or more systems, an optional human readable `name` field to be used
 * to summarize the trade and a required `product` field that may be used to provide
 * additional detail about the trade, which is currently typed as a unspecified Context
 * type, but `product` is expected to be standardized in future.
 *
 * The Trade schema does not explicitly include identifiers in the id section, as there is
 * not a common standard for such identifiers. Applications can, however, populate this part
 * of the contract with custom identifiers if so desired.
 */
export interface TradeElement {
    /**
     * One or more identifiers that refer to the trade in an OMS, EMS or related system.
     * Specific key names for systems are expected to be standardized in future.
     */
    id: {
        [key: string]: string;
    };
    /**
     * A human-readable summary of the trade.
     */
    name?: string;
    /**
     * A product that is the subject of the trade.
     */
    product: ProductObject;
    type: "fdc3.trade";
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A context type representing the result of a transaction initiated via FDC3, which SHOULD
 * be returned as an `IntentResult` by intents that create, retrieve, update or delete
 * content or records in another application. Its purpose is to provide a status and message
 * (where needed) for the transaction and MAY wrap a returned context object.
 */
export interface TransactionResult {
    /**
     * A context object returned by the transaction, possibly with updated data.
     */
    context?: ContextElement;
    /**
     * The status of the transaction being reported.
     */
    status: TransactionStatus;
    type: "fdc3.transactionResult";
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * The status of the transaction being reported.
 */
export type TransactionStatus = "Created" | "Deleted" | "Updated" | "Failed";
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
/**
 * A context type representing the price and value of a holding.
 */
export interface Valuation {
    /**
     * The valuation currency, which should conform to 3 character alphabetic codes defined in
     * [ISO 4217](https://www.iso.org/iso-4217-currency-codes.html)
     */
    CURRENCY_ISOCODE: string;
    /**
     * The time at which this valuation expires, encoded according to [ISO
     * 8601-1:2019](https://www.iso.org/standard/70907.html) with a timezone indicator included.
     */
    expiryTime?: Date;
    /**
     * The price per unit the the valuation is based on.
     */
    price?: number;
    type: "fdc3.valuation";
    /**
     * The time at which the valuation was performed, encoded according to [ISO
     * 8601-1:2019](https://www.iso.org/standard/70907.html) with a timezone indicator included.
     */
    valuationTime?: Date;
    /**
     * The value of the holding, expresses in the nominated currency.
     */
    value: number;
    id?: {
        [key: string]: any;
    };
    name?: string;
    [property: string]: any;
}
/**
 * Free text to be used for a keyword search
 *
 * `interactionType` SHOULD be one of `'Instant Message'`, `'Email'`, `'Call'`, or
 * `'Meeting'` although other string values are permitted.
 */
export declare class Convert {
    static toAction(json: string): Action;
    static actionToJson(value: Action): string;
    static toChart(json: string): Chart;
    static chartToJson(value: Chart): string;
    static toChatInitSettings(json: string): ChatInitSettings;
    static chatInitSettingsToJson(value: ChatInitSettings): string;
    static toChatMessage(json: string): ChatMessage;
    static chatMessageToJson(value: ChatMessage): string;
    static toChatRoom(json: string): ChatRoom;
    static chatRoomToJson(value: ChatRoom): string;
    static toChatSearchCriteria(json: string): ChatSearchCriteria;
    static chatSearchCriteriaToJson(value: ChatSearchCriteria): string;
    static toContact(json: string): Contact;
    static contactToJson(value: Contact): string;
    static toContactList(json: string): ContactList;
    static contactListToJson(value: ContactList): string;
    static toContext(json: string): Context;
    static contextToJson(value: Context): string;
    static toCountry(json: string): Country;
    static countryToJson(value: Country): string;
    static toCurrency(json: string): Currency;
    static currencyToJson(value: Currency): string;
    static toEmail(json: string): Email;
    static emailToJson(value: Email): string;
    static toInstrument(json: string): Instrument;
    static instrumentToJson(value: Instrument): string;
    static toInstrumentList(json: string): InstrumentList;
    static instrumentListToJson(value: InstrumentList): string;
    static toInteraction(json: string): Interaction;
    static interactionToJson(value: Interaction): string;
    static toMessage(json: string): Message;
    static messageToJson(value: Message): string;
    static toNothing(json: string): Nothing;
    static nothingToJson(value: Nothing): string;
    static toOrder(json: string): Order;
    static orderToJson(value: Order): string;
    static toOrderList(json: string): OrderList;
    static orderListToJson(value: OrderList): string;
    static toOrganization(json: string): Organization;
    static organizationToJson(value: Organization): string;
    static toPortfolio(json: string): Portfolio;
    static portfolioToJson(value: Portfolio): string;
    static toPosition(json: string): Position;
    static positionToJson(value: Position): string;
    static toProduct(json: string): Product;
    static productToJson(value: Product): string;
    static toTimeRange(json: string): TimeRange;
    static timeRangeToJson(value: TimeRange): string;
    static toTrade(json: string): Trade;
    static tradeToJson(value: Trade): string;
    static toTradeList(json: string): TradeList;
    static tradeListToJson(value: TradeList): string;
    static toTransactionResult(json: string): TransactionResult;
    static transactionResultToJson(value: TransactionResult): string;
    static toValuation(json: string): Valuation;
    static valuationToJson(value: Valuation): string;
}
//# sourceMappingURL=ContextTypes.d.ts.map