betfair-exchange-api/dist/stream-api-client.d.ts

A TypeScript client for the Betfair Exchange API

import { EventEmitter } from 'events';
export declare enum StreamOperation {
    AUTHENTICATION = "authentication",
    MARKET_SUBSCRIPTION = "marketSubscription",
    ORDER_SUBSCRIPTION = "orderSubscription",
    HEARTBEAT = "heartbeat"
}
export declare enum ChangeType {
    SUB_IMAGE = "SUB_IMAGE",
    RESUB_DELTA = "RESUB_DELTA",
    HEARTBEAT = "HEARTBEAT"
}
export declare enum SegmentType {
    SEG_START = "SEG_START",
    SEG = "SEG",
    SEG_END = "SEG_END"
}
export type MarketDataFilter = {
    fields?: string[];
    ladderLevels?: number;
};
export type MarketSubscriptionMessage = {
    op: StreamOperation.MARKET_SUBSCRIPTION;
    id: number;
    marketFilter: {
        marketIds?: string[];
        bspMarket?: boolean;
        bettingTypes?: string[];
        eventTypeIds?: string[];
        eventIds?: string[];
        turnInPlayEnabled?: boolean;
        marketTypes?: string[];
        venues?: string[];
        countryCodes?: string[];
        raceTypes?: string[];
    };
    marketDataFilter?: MarketDataFilter;
    conflateMs?: number;
    heartbeatMs?: number;
    segmentationEnabled?: boolean;
    initialClk?: string;
    clk?: string;
};
export type OrderFilter = {
    accountIds?: number[];
    includeOverallPosition?: boolean;
    customerStrategyRefs?: string[];
    partitionMatchedByStrategyRef?: boolean;
};
export type OrderSubscriptionMessage = {
    op: StreamOperation.ORDER_SUBSCRIPTION;
    id: number;
    orderFilter?: OrderFilter;
    conflateMs?: number;
    heartbeatMs?: number;
    segmentationEnabled?: boolean;
    initialClk?: string;
    clk?: string;
};
export type AuthenticationMessage = {
    op: StreamOperation.AUTHENTICATION;
    id: number;
    appKey: string;
    session: string;
};
export type HeartbeatMessage = {
    op: StreamOperation.HEARTBEAT;
    id: number;
};
export type RequestMessage = MarketSubscriptionMessage | OrderSubscriptionMessage | AuthenticationMessage | HeartbeatMessage;
export type StatusMessage = {
    op: 'status';
    id: number;
    statusCode: 'SUCCESS' | 'FAILURE';
    connectionClosed?: boolean;
    errorCode?: string;
    errorMessage?: string;
    connectionsAvailable?: number;
};
export type ConnectionMessage = {
    op: 'connection';
    connectionId: string;
};
export type MarketChangeMessage = {
    op: 'mcm';
    id?: number;
    ct?: ChangeType;
    clk?: string;
    heartbeatMs?: number;
    pt?: number;
    initialClk?: string;
    mc?: MarketChange[];
    conflateMs?: number;
    segmentType?: SegmentType;
    status?: number;
};
export type OrderChangeMessage = {
    op: 'ocm';
    id?: number;
    ct?: ChangeType;
    clk?: string;
    heartbeatMs?: number;
    pt?: number;
    initialClk?: string;
    oc?: OrderChange[];
    conflateMs?: number;
    segmentType?: SegmentType;
    status?: number;
};
export type ResponseMessage = StatusMessage | ConnectionMessage | MarketChangeMessage | OrderChangeMessage;
export type MarketChange = {
    id: string;
    marketDefinition?: MarketDefinition;
    rc?: RunnerChange[];
    img?: boolean;
    tv?: number;
    con?: boolean;
};
export type MarketDefinition = {
    bettingType?: string;
    bspMarket?: boolean;
    turnInPlayEnabled?: boolean;
    persistenceEnabled?: boolean;
    marketBaseRate?: number;
    eventId?: string;
    eventTypeId?: string;
    numberOfWinners?: number;
    marketType?: string;
    marketTime?: string;
    suspendTime?: string;
    bspReconciled?: boolean;
    complete?: boolean;
    inPlay?: boolean;
    crossMatching?: boolean;
    runnersVoidable?: boolean;
    numberOfActiveRunners?: number;
    betDelay?: number;
    status?: string;
    runners?: RunnerDefinition[];
    regulators?: string[];
    discountAllowed?: boolean;
    timezone?: string;
    openDate?: string;
    version?: number;
    priceLadderDefinition?: PriceLadderDefinition;
    keyLineDescription?: KeyLineDefinition;
    lineRangeInfo?: LineRangeInfo;
};
export type LineRangeInfo = {
    maxUnitValue: number;
    minUnitValue: number;
    interval: number;
    marketUnit: string;
};
export type PriceLadderDefinition = {
    type: string;
};
export type KeyLineDefinition = {
    kl: KeyLineSelection[];
};
export type KeyLineSelection = {
    id: number;
    hc: number;
};
export type RunnerDefinition = {
    id: number;
    sortPriority: number;
    status: string;
    adjustmentFactor?: number;
    removalDate?: string;
    hc?: number;
    bsp?: number;
};
export type RunnerChange = {
    id: number;
    hc?: number;
    ltp?: number;
    tv?: number;
    trd?: [number, number][];
    batb?: [number, number, number][];
    batl?: [number, number, number][];
    bdatb?: [number, number, number][];
    bdatl?: [number, number, number][];
    spn?: number;
    spf?: number;
    atb?: [number, number][];
    atl?: [number, number][];
    spb?: [number, number][];
    spl?: [number, number][];
};
export type OrderChange = {
    id: string;
    orc?: OrderRunnerChange[];
    closed?: boolean;
    fullImage?: boolean;
};
export type OrderRunnerChange = {
    id: number;
    hc?: number;
    fullImage?: boolean;
    mb?: [number, number][];
    ml?: [number, number][];
    uo?: UnmatchedOrder[];
    smc?: {
        [key: string]: StrategyMatchChange;
    };
};
export type StrategyMatchChange = {
    mb?: [number, number][];
    ml?: [number, number][];
};
export type UnmatchedOrder = {
    id: string;
    p: number;
    s: number;
    side: 'B' | 'L';
    status: 'E' | 'EC';
    pt: 'L' | 'P' | 'MOC';
    ot: 'L' | 'LOC' | 'MOC';
    pd: number;
    sm: number;
    sr: number;
    sl: number;
    sc: number;
    sv: number;
    bsp?: number;
    avp?: number;
    md?: number;
    cd?: number;
    ld?: number;
    lsrc?: string;
    rfo?: string;
    rfs?: string;
};
interface BetfairStreamConfig {
    streamApiUrl?: string;
}
export declare interface BetfairStreamClient {
    on(event: 'connected', listener: () => void): this;
    on(event: 'disconnected', listener: () => void): this;
    on(event: 'error', listener: (error: Error) => void): this;
    on(event: 'status', listener: (status: StatusMessage) => void): this;
    on(event: 'connection', listener: (connection: ConnectionMessage) => void): this;
    on(event: 'marketChange', listener: (marketChange: MarketChangeMessage) => void): this;
    on(event: 'orderChange', listener: (orderChange: OrderChangeMessage) => void): this;
}
export declare class BetfairStreamClient extends EventEmitter {
    private host;
    private port;
    private appKey;
    private sessionToken;
    private socket;
    private buffer;
    private connectionId;
    private authenticated;
    private requestIdCounter;
    private conflateMs?;
    private heartbeatMs?;
    private segmentationEnabled?;
    private marketSubscriptionInitialClk?;
    private marketSubscriptionClk?;
    private orderSubscriptionInitialClk?;
    private orderSubscriptionClk?;
    constructor(appKey: string, sessionToken: string, config?: BetfairStreamConfig);
    connect(): void;
    disconnect(): void;
    authenticate(): void;
    subscribeToMarkets(marketFilter?: MarketSubscriptionMessage['marketFilter'], marketDataFilter?: MarketDataFilter, conflateMs?: number, heartbeatMs?: number, segmentationEnabled?: boolean): void;
    subscribeToOrders(orderFilter?: OrderFilter, conflateMs?: number, heartbeatMs?: number, segmentationEnabled?: boolean): void;
    sendHeartbeat(): void;
    private handleData;
    private processMessage;
    private sendMessage;
    private getNextRequestId;
    getConnectionId(): string | null;
    isAuthenticated(): boolean;
}
export {};