@glue42/bbg-market-data/dist/cjs/bbg-market-data-api.d.ts

A high-level API that wraps existing Glue42 Bloomberg Bridge Market Data interop methods. The API is based on the jBloomberg open source wrapper.

import { Glue42Core } from "@glue42/core";
import { HistoricalDataRequestArguments } from "./requests/historical-data-request/request-args";
import { HistoricalDataRequest } from "./requests/historical-data-request";
import { ReferenceDataRequestArguments, ReferenceDataRequest } from "./requests/reference-data-request";
import { InstrumentListRequest, InstrumentListRequestArguments } from "./requests/instrument-list-request";
import { FieldListRequest, FieldListRequestArguments, FieldSearchRequestArguments, FieldSearchRequest } from "./requests/field-request";
import { UserEntitlementsRequest, UserEntitlementsRequestArguments } from "./requests/user-entitlements-request";
import { IntraDayBarRequestArguments, IntraDayBarRequest } from "./requests/intraday-bar-request";
import { SnapshotRequestArguments, SnapshotRequest } from "./requests/snapshot-request";
import { Subscription } from "./core/types/subscription-request";
import { UnsubscribeFunction } from "callback-registry";
import { ConnectionStatus } from "./connection/connection-status";
import { Logger } from "./logger/types";
import { BloombergSession, SessionSettings } from "./sessions/types";
import { MarketDataSubscriptionRequest } from "./requests/mkt-data-subscription";
import { IntraDayTickRequest, IntraDayTickRequestArguments } from "./requests/intraday-tick-request";
import { GenericRequest, GenericRequestArgs } from "./requests/generic-request";
export interface ProtocolMethods {
    CreateSubscriptionRequest: Glue42Core.Interop.MethodDefinition;
    CreateRequest: Glue42Core.Interop.MethodDefinition;
    CancelRequests: Glue42Core.Interop.MethodDefinition;
    CloseSession: Glue42Core.Interop.MethodDefinition;
    SubscribeStatus: Glue42Core.Interop.MethodDefinition;
}
/**
 * Configuration object for the BBG Market Data library.
 */
export interface BBGMarketDataConfig {
    /**
     * Whether to enable debugging mode (logging).
     * @default false
     */
    debug?: boolean;
    /**
     * A custom logger that implements the `Logger` interface.
     * If not provided, a default library console logger is used.
     */
    logger?: Logger;
    /**
     * Controls the log level of the default console logger.
     * Default "info".
     */
    logLevel?: "trace" | "debug" | "log" | "info" | "warn" | "error";
    /**
     * Reconnection period in milliseconds.
     * @default 5000 ms.
     * Min value 5000 ms.
     */
    connectionPeriodMsecs?: number;
    /**
     * To use non-default session options and session identity options.
     */
    sessionSettings?: SessionSettings;
    /**
     * Use to override some or all of the default protocol methods.
     * @param defaultMethods The default protocol methods.
     * @returns Overrides.
     */
    overrideProtocolMethods?: (defaultMethods: ProtocolMethods) => Partial<ProtocolMethods>;
}
/**
 * A factory function the creates a new BBGMarketDataAPI instance.
 */
export interface BBGMarketDataFactory {
    (interop: Glue42Core.Interop.API, config: BBGMarketDataConfig): BBGMarketDataAPI;
}
/**
 * API for handling sessions.
 */
export interface SessionsAPI {
    /**
     * Returns all currently open user-defined sessions.
     */
    all: string[];
    /**
     * Allows you to and close an existing user defined session by its name.
     * @param session The name of the session.
     */
    close: (session: string) => Promise<void>;
    /**
     * Creates a config for a new session which lifetime is bound to the Interop instance's lifetime.
     * @param session The name of the session.
     */
    create: (settings?: SessionSettings) => Promise<BloombergSession>;
}
/**
 * **BBG Market Data** is a high level API which provides access to the Market Data Feed service of Bloomberg.
 * The API enables building request/response and subscription requests.
 * It provides a flattened request arguments structure. Instead of passing string arguments, as with the standard Bloomberg API,
 * the possible options are wrapped in primitive values and enumerations.
 * Any method will throw an error when an attempt to create a request with invalid request arguments is made.
 *
 * Below is a typescript example for making a `HistoricalData` request:
 *
 * @example
 * ```typescript
 * import BBGMarketData from "bbg-market-data";
 * import GlueCoreFactory from "@glue42/core"
 *
 * GlueCoreFactory()
 *     .then((glue) => {
 *         const bbgMarketData = BBGMarketData(glue.interop, { debug: false });
 *
 *         const requestArguments = {
 *             securities: ["IBM US Equity"],
 *             fields: ["PX_LAST", "OPEN"],
 *             startDate: "20060101",
 *             endDate: "20061231",
 *             periodicityAdjustment: PeriodicityAdjustment.ACTUAL,
 *             periodicitySelection: PeriodicitySelection.MONTHLY,
 *             maxDataPoints: 100,
 *             returnEids: true,
 *             nonTradingDayFillOption: FillOptions.NON_TRADING_WEEKDAYS,
 *             nonTradingDayFillMethod: FillMethod.PREVIOUS_VALUE
 *         };
 *
 *         // The request is created and can be sent to the Bloomberg service.
 *         const request = bbgMarketData.createHistoricalDataRequest(requestArguments);
 *
 *
 *         request.onStatus((status: RequestStatus) => {
 *             // Track the current request status.
 *         });
 *
 *         request.onEvent((event: BloombergEvent) => {
 *             // Handle events from Bloomberg that are related to this request.
 *         });
 *
 *         request.onError((error) => {
 *             // Handle errors. The request is considered failed and no more events will be received.
 *         });
 *
 *         request.onData((data) => {
 *             // Handle response data.
 *         });
 *
 *         // Send the actual request to the Bloomberg service.
 *         // The API will create a new session which will close immediately after the request completes, fails or is closed.
 *         request
 *          .open({ session: Session.CreateNew })
            .then((response: HistoricalData[] | undefined) => {
              // Handle aggregated response.
            });
 *     });
 * ```
 */
export interface BBGMarketDataAPI {
    /**
     * Library version.
     */
    version: string;
    info: {
        /**
         * A unique library instance id.
         */
        apiId: string;
    };
    ready: Promise<void>;
    /**
     * Creates a new instance of a `GenericRequest`.
     * @param requestArguments - Arguments for the request to the Bloomberg service.
     * @param service - A Bloomberg service.
     * @param operation - A service operation.
     */
    createGenericRequest(requestArguments: GenericRequestArgs, service: string, operation: string): GenericRequest;
    /**
     * Creates a new instance of a `HistoricalDataRequest`.
     * @param requestArguments - Arguments for the request to the Bloomberg service.
     */
    createHistoricalDataRequest(requestArguments: HistoricalDataRequestArguments): HistoricalDataRequest;
    /**
     * Creates a new instance of an `IntraDayBarRequest`.
     * @param requestArguments - Arguments for the request to the Bloomberg service.
     */
    createIntraDayBarRequest(requestArguments: IntraDayBarRequestArguments): IntraDayBarRequest;
    /**
     * Creates a new instance of an `IntraDayTickRequest`.
     * @param requestArguments - Arguments for the request to the Bloomberg service.
   */
    createIntraDayTickRequest(requestArguments: IntraDayTickRequestArguments): IntraDayTickRequest;
    /**
     * Creates a new instance of a `ReferenceDataRequest`.
     * @param requestArguments - Arguments for the request to the Bloomberg service.
     */
    createReferenceDataRequest(requestArguments: ReferenceDataRequestArguments): ReferenceDataRequest;
    /**
     * Creates a new instance of an `InstrumentListRequest`.
     * @param requestArguments - Arguments for the request to the Bloomberg service.
     */
    createInstrumentListRequest(requestArguments: InstrumentListRequestArguments): InstrumentListRequest;
    /**
     * Creates a new instance of a `SnapshotRequest`.
     * @param requestArguments - Arguments for the request to the Bloomberg service.
     */
    createSnapshotRequest(requestArguments: SnapshotRequestArguments): SnapshotRequest;
    /**
     * Creates a new instance of a `FieldListRequest`.
     * @param requestArguments - Arguments for the request to the Bloomberg service.
     */
    createFieldListRequest(requestArguments: FieldListRequestArguments): FieldListRequest;
    /**
     * Creates a new instance of a `FieldSearchRequest`.
     * @param requestArguments - Arguments for the request to the Bloomberg service.
     */
    createFieldSearchRequest(requestArguments: FieldSearchRequestArguments): FieldSearchRequest;
    /**
     * Creates a new instance of a `UserEntitlementsRequest`.
     * @param requestArguments - Arguments for the request to the Bloomberg service.
     */
    createUserEntitlementsRequest(requestArguments: UserEntitlementsRequestArguments): UserEntitlementsRequest;
    /**
     * Creates a new instance of a `SubscriptionRequest`. Streaming data is retrieved through the `//blp/mktdata` service.
     * @param requestArguments - Arguments for the request to the Bloomberg service.
     */
    createMarketDataRequest(requestArguments: Array<Subscription>): MarketDataSubscriptionRequest;
    /**
     * The Sessions API allows you to retrieve a list of all opened user-defined sessions. The API exposes the Glue42 protocol to close a session.
     */
    sessions: SessionsAPI;
    /**
     * Attaches a callback for handling changes of the MDF Api `ConnectionStatus`.
     * @param callback - Handler function for connection status changes.
     */
    onConnectionStatusChanged(callback: (status: ConnectionStatus) => void): UnsubscribeFunction;
}