@polygon.io/client-js/dist/main.d.ts

Isomorphic Javascript client for Polygon.io Stocks, Forex, and Crypto APIs

import * as websocket from 'websocket';

interface IPolygonQuery {
    [key: string]: string | number | boolean | undefined;
}
interface IPolygonEdgeHeaders extends Partial<Record<string, string>> {
    'X-Polygon-Edge-ID'?: string;
    'X-Polygon-Edge-IP-Address'?: string;
    'X-Polygon-Edge-User-Agent'?: string;
}
declare type IHeaders = IPolygonEdgeHeaders | HeadersInit;
interface IRequestInit extends Omit<RequestInit, 'headers'> {
    headers?: IHeaders;
}
interface IGlobalOptions extends IRequestInit {
    trace?: boolean;
    pagination?: boolean;
}
declare type IRequestOptions = IGlobalOptions;
interface IPolygonQueryWithCredentials extends IPolygonQuery {
    apiKey: string | boolean;
}
declare type IGet = (path: string, query: IPolygonQuery, options: IRequestOptions) => Promise<any>;
declare type ICurriedGet = (apiKey: string, apiBase: string, globalOptions?: IGlobalOptions) => IGet;
declare type IStructuredError = InstanceType<typeof StructuredError>;
declare class StructuredError extends Error {
    status: string;
    request_id: string;
    constructor(message: string, status?: string, requestId?: string);
}
declare const getWithGlobals: ICurriedGet;

interface IAggsResults {
    T?: string;
    c?: number;
    h?: number;
    l?: number;
    n?: number;
    o?: number;
    t?: number;
    v?: number;
    vw?: number;
}
interface IAggsQuery extends IPolygonQuery {
    adjusted?: "true" | "false";
    sort?: "asc" | "desc";
    limit?: number;
}
interface IAggs {
    ticker?: string;
    adjusted?: boolean;
    queryCount?: number;
    request_id?: number;
    resultsCount?: number;
    status?: string;
    results?: IAggsResults[];
    next_url?: string;
}

interface IAggsGroupedDailyQuery extends IPolygonQuery {
    adjusted?: "true" | "false";
}
interface IAggsGroupedDaily {
    adjusted?: boolean;
    queryCount?: number;
    request_id?: number;
    status?: string;
    results: IAggsResults[];
}

interface IAggsPreviousCloseQuery extends IPolygonQuery {
    adjusted?: "true" | "false";
}
interface IAggsPreviousClose {
    ticker?: string;
    adjusted?: boolean;
    queryCount?: number;
    request_id?: string;
    resultsCount?: number;
    status?: string;
    count?: number;
    results?: IAggsResults[];
}

interface ITradeInfo {
    conditions: number[];
    correction: number;
    exchange: number;
    id: string;
    participant_timestamp: number;
    price: number;
    sequence_number: number;
    sip_timestamp: number;
    size: number;
    tape: number;
    trf_id: number;
    trf_timestamp: number;
}
interface ITradesQuotesQuery extends IPolygonQuery {
    timestamp?: string;
    "timestamp.lt"?: string;
    "timestamp.lte"?: string;
    "timestamp.gt"?: string;
    "timestamp.gte"?: string;
    order?: "asc" | "desc";
    limit?: number;
    sort?: "timestamp";
}
interface ITrades {
    next_url: string;
    request_id?: string;
    results?: ITradeInfo[];
    status?: string;
}

interface ITick {
    c?: string[];
    p?: number;
    s?: number;
    t?: number;
    x?: number;
}

interface ICryptoDailyOpenCloseQuery extends IPolygonQuery {
    adjusted?: "true" | "false";
}
interface ICryptoDailyOpenClose {
    close?: number;
    closeingTrades?: ITick;
    day?: string;
    isUTC?: boolean;
    open?: number;
    openTrades?: ITick;
    symbol?: string;
}

interface ICryptoTradeInfo {
    conditions: number[];
    exchange: number;
    id: string;
    participant_timestamp: number;
    price: number;
    size: number;
}
interface ICryptoTrade {
    next_url?: string;
    request_id?: string;
    results?: ICryptoTradeInfo[];
    status?: string;
}

interface ICryptoLastTrade {
    status?: string;
    request_id?: string;
    symbol?: string;
    last?: {
        conditions?: number[];
        exchange?: number;
        price?: number;
        size?: number;
        timestamp?: number;
    };
}

interface SnapshotDay$3 {
    c?: number;
    h?: number;
    l?: number;
    o?: number;
    v?: number;
    vw?: number;
}
interface SnapshotLastTrade$2 {
    c?: string[];
    i?: string;
    p?: number;
    s?: number;
    t?: number;
    x?: number;
}
interface SnapshotMin$2 {
    c?: number;
    h?: number;
    l?: number;
    o?: number;
    v?: number;
    vw?: number;
    t?: number;
    n?: number;
}
interface SnapshotPrevDay$2 {
    c?: number;
    h?: number;
    l?: number;
    o?: number;
    v?: number;
    vw?: number;
}
interface SnapshotInfo$3 {
    day?: SnapshotDay$3;
    lastTrade?: SnapshotLastTrade$2;
    min?: SnapshotMin$2;
    prevDay?: SnapshotPrevDay$2;
    ticker?: string;
    todaysChange?: number;
    todaysChangePerc?: number;
    updated?: number;
}
interface ICryptoSnapshotAllTickersQuery extends IPolygonQuery {
    tickers?: string;
}
interface ICryptoSnapshotTickers {
    count?: number;
    status?: string;
    tickers?: SnapshotInfo$3[];
}
interface ICryptoSnapshot {
    status?: string;
    request_id?: string;
    ticker?: SnapshotInfo$3;
}
interface IFullBookTick {
    p?: number;
    x?: {
        [key: string]: string;
    };
}
interface ICryptoSnapshotFullBookL2 {
    status?: string;
    data?: {
        ask?: IFullBookTick[];
        bidCount?: number;
        bids?: IFullBookTick[];
        spread?: number;
        ticker?: string;
        updated?: number;
    };
}

interface IBranding {
    icon_url: string;
    logo_url: string;
}
interface IOptions {
    contract_type: 'put' | 'call' | 'other';
    exercise_style: 'american' | 'european' | 'bermudan';
    expiration_date: string;
    shares_per_contract: number;
    strike_price: number;
    underlying_ticker: string;
}
interface ISession {
    change: number;
    change_percent: number;
    close: number;
    early_trading_change: number;
    early_trading_change_percent: number;
    high: number;
    late_trading_change: number;
    late_trading_change_percent: number;
    low: number;
    open: number;
    previous_close: number;
    volume: number;
}
interface ISummariesResults {
    branding: IBranding;
    market_status: string;
    name: string;
    option: IOptions;
    price: number;
    session: ISession;
    ticker: string;
    type: 'stock' | 'option' | 'forex' | 'crypto';
}
interface ISummariesQuery extends IPolygonQuery {
    'ticker.any_of'?: string;
}
interface ISummaries {
    request_id?: string;
    status?: string;
    results?: ISummariesResults[];
}

interface IValue {
    histogram?: number;
    signal?: number;
    timestamp?: number;
    value?: number;
}
interface IUnderyling {
    aggregates: IAggsResults[];
    url?: string;
}
interface ITechnicalIndicatorsQuery extends IPolygonQuery {
    timestamp?: string;
    "timestamp.lt"?: string;
    "timestamp.lte"?: string;
    "timestamp.gt"?: string;
    "timestamp.gte"?: string;
    timespan?: 'minute' | 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
    adjusted?: boolean;
    short_window?: number;
    long_window?: number;
    signal_window?: number;
    window?: number;
    series_type?: 'open' | 'high' | 'low' | 'close';
    expand_underlying?: boolean;
    order?: 'asc' | 'desc';
    limit?: number;
}
interface ISmaResults {
    underlying?: IUnderyling;
    values: IValue[];
}
interface ISma {
    next_url?: string;
    request_id?: string;
    status?: string;
    results?: ISmaResults;
}

interface IEmaResults {
    underlying?: IUnderyling;
    values: IValue[];
}
interface IEma {
    next_url?: string;
    request_id?: string;
    status?: string;
    results?: IEmaResults;
}

interface IMacdResults {
    underlying?: IUnderyling;
    values: IValue[];
}
interface IMacd {
    next_url?: string;
    request_id?: string;
    status?: string;
    results?: IMacdResults;
}

interface IRsiResults {
    underlying?: IUnderyling;
    values: IValue[];
}
interface IRsi {
    next_url?: string;
    request_id?: string;
    status?: string;
    results?: IRsiResults;
}

interface UniversalSnapshotSession {
    change?: number;
    change_percent?: number;
    early_trading_change?: number;
    early_trading_change_percent?: number;
    regular_trading_change?: number;
    regular_trading_change_percent?: number;
    late_trading_change?: number;
    late_trading_change_percent?: number;
    close?: number;
    high?: number;
    low?: number;
    open?: number;
    volume?: number;
    previous_close?: number;
    price?: number;
}
interface UniversalSnapshotLastQuote {
    last_updated?: number;
    timeframe?: string;
    ask?: number;
    ask_size?: number;
    ask_exchange?: number;
    bid?: number;
    bid_size?: number;
    bid_exchange?: number;
    midpoint?: number;
    exchange?: number;
}
interface UniversalSnapshotLastTrade {
    last_updated?: number;
    timeframe?: string;
    id?: string;
    price?: number;
    size?: number;
    exchange?: number;
    conditions?: number[];
    participant_timestamp?: number;
    sip_timestamp?: number;
}
interface UniversalSnapshotDetails {
    contract_type?: string;
    exercise_style?: string;
    expiration_date?: string;
    shares_per_contract?: number;
    strike_price?: number;
}
interface UniversalSnapshotGreeks {
    delta?: number;
    gamma?: number;
    theta?: number;
    vega?: number;
}
interface UniversalSnapshotUnderlyingAsset {
    change_to_break_even?: number;
    last_updated?: number;
    price?: number;
    ticker?: string;
    timeframe?: string;
}
interface UniversalSnapshotInfo {
    market_status?: string;
    name?: string;
    ticker?: string;
    type?: string;
    session?: UniversalSnapshotSession;
    last_quote?: UniversalSnapshotLastQuote;
    last_trade?: UniversalSnapshotLastTrade;
    details?: UniversalSnapshotDetails;
    greeks?: UniversalSnapshotGreeks;
    implied_volatility?: number;
    open_interest?: number;
    underlying_asset?: UniversalSnapshotUnderlyingAsset;
    value?: number;
    break_even_price?: number;
    fmv?: number;
}
interface IUniversalSnapshotQuery extends IPolygonQuery {
    "ticker.any_of"?: string;
}
interface IUniversalSnapshot {
    status?: string;
    request_id?: string;
    results?: UniversalSnapshotInfo[];
}
declare const universalSnapshot: (get: IGet, query?: IUniversalSnapshotQuery, options?: IRequestOptions) => Promise<IUniversalSnapshot>;

interface ICryptoClient {
    aggregates: (ticker: string, multiplier: number, timespan: string, from: string, to: string, query?: IAggsQuery, options?: IRequestOptions) => Promise<IAggs>;
    aggregatesGroupedDaily: (date: string, query?: IAggsGroupedDailyQuery, options?: IRequestOptions) => Promise<IAggsGroupedDaily>;
    summaries: (query?: ISummariesQuery, options?: IRequestOptions) => Promise<ISummaries>;
    dailyOpenClose: (from: string, to: string, date: string, query?: ICryptoDailyOpenCloseQuery, options?: IRequestOptions) => Promise<ICryptoDailyOpenClose>;
    trades: (cryptoTicker: string, query?: ITradesQuotesQuery, options?: IRequestOptions) => Promise<ICryptoTrade>;
    lastTrade: (from: string, to: string, query?: IPolygonQuery, options?: IRequestOptions) => Promise<ICryptoLastTrade>;
    previousClose: (symbol: string, query?: IAggsPreviousCloseQuery, options?: IRequestOptions) => Promise<IAggsPreviousClose>;
    snapshotAllTickers: (query?: ICryptoSnapshotAllTickersQuery, options?: IRequestOptions) => Promise<ICryptoSnapshotTickers>;
    snapshotGainersLosers: (direction: "gainers" | "losers", query?: IPolygonQuery, options?: IRequestOptions) => Promise<ICryptoSnapshotTickers>;
    snapshotTicker: (symbol: string, query?: IPolygonQuery, options?: IRequestOptions) => Promise<ICryptoSnapshot>;
    snapshotTickerFullBookL2: (symbol: string, query?: IPolygonQuery, options?: IRequestOptions) => Promise<ICryptoSnapshotFullBookL2>;
    sma: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<ISma>;
    ema: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IEma>;
    macd: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IMacd>;
    rsi: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IRsi>;
    universalSnapshot: (query?: IUniversalSnapshotQuery, options?: IRequestOptions) => Promise<IUniversalSnapshot>;
}
declare const cryptoClient: (apiKey: any, apiBase?: string, options?: IRequestOptions) => ICryptoClient;

interface IConversionQuery extends IPolygonQuery {
    amount?: number;
    precision?: number;
}
interface IConversion {
    status?: string;
    converted?: number;
    initialAmmount?: number;
    last?: {
        ask?: number;
        bid?: number;
        exchange?: number;
        timestamp?: number;
    };
    to?: string;
}

interface IForexQuotesInfo {
    ask_exchange: number;
    ask_price: number;
    bid_exchange: number;
    bid_price: number;
    participant_timestamp: number;
}
interface IForexQuotes {
    next_url?: string;
    request_id?: string;
    results?: IForexQuotesInfo[];
    status?: string;
}

interface IForexLastQuote {
    status?: string;
    request_id?: string;
    symbol?: string;
    last?: {
        ask?: number;
        bid?: number;
        exchange?: number;
        timestamp?: number;
    };
}

interface SnapshotDay$2 {
    c?: number;
    h?: number;
    l?: number;
    o?: number;
    v?: number;
}
interface SnapshotLastQuote$2 {
    a?: number;
    b?: number;
    t?: number;
    x?: number;
}
interface SnapshotMin$1 {
    c?: number;
    h?: number;
    l?: number;
    o?: number;
    v?: number;
    t?: number;
    n?: number;
}
interface SnapshotPrevDay$1 {
    c?: number;
    h?: number;
    l?: number;
    o?: number;
    v?: number;
    vw?: number;
}
interface SnapshotInfo$2 {
    day?: SnapshotDay$2;
    lastQuote?: SnapshotLastQuote$2;
    min?: SnapshotMin$1;
    prevDay?: SnapshotPrevDay$1;
    ticker?: string;
    todaysChange?: number;
    todayChangePerc?: number;
    updated?: number;
}
interface IForexSnapshotAllTickersQuery extends IPolygonQuery {
    tickers?: string;
}
interface IForexSnapshotTickers {
    count?: number;
    status?: string;
    tickers?: SnapshotInfo$2[];
}
interface IForexSnapshot {
    status?: string;
    request_id?: string;
    ticker?: SnapshotInfo$2;
}

interface IRealTimeCurrencyConversionQuery extends IPolygonQuery {
    amount?: number;
    precision?: number;
}
interface IRealTimeCurrencyConversion {
    status?: string;
    from?: string;
    to?: string;
    initialAmount?: number;
    converted?: number;
    lastTrade?: {
        ask?: number;
        bid?: number;
        exchange?: number;
        timestamp?: number;
    };
    symbol?: string;
}

interface IForexClient {
    aggregates: (ticker: string, multiplier: number, timespan: string, from: string, to: string, query?: IAggsQuery, options?: IRequestOptions) => Promise<IAggs>;
    aggregatesGroupedDaily: (date: string, query?: IAggsGroupedDailyQuery, options?: IRequestOptions) => Promise<IAggsGroupedDaily>;
    summaries: (query?: ISummariesQuery, options?: IRequestOptions) => Promise<ISummaries>;
    conversion: (from: string, to: string, query?: IConversionQuery, options?: IRequestOptions) => Promise<IConversion>;
    quotes: (fxTicker: string, query?: ITradesQuotesQuery, options?: IRequestOptions) => Promise<IForexQuotes>;
    lastQuote: (from: string, to: string, query?: IPolygonQuery, options?: IRequestOptions) => Promise<IForexLastQuote>;
    previousClose: (symbol: string, query?: IAggsPreviousCloseQuery, options?: IRequestOptions) => Promise<IAggsPreviousClose>;
    snapshotAllTickers: (query?: IForexSnapshotAllTickersQuery, options?: IRequestOptions) => Promise<IForexSnapshotTickers>;
    snapshotGainersLosers: (direction: "gainers" | "losers", query?: IPolygonQuery, options?: IRequestOptions) => Promise<IForexSnapshotTickers>;
    snapshotTicker: (symbol: string, query?: IPolygonQuery, options?: IRequestOptions) => Promise<IForexSnapshot>;
    sma: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<ISma>;
    ema: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IEma>;
    macd: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IMacd>;
    rsi: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IRsi>;
    universalSnapshot: (query?: IUniversalSnapshotQuery, options?: IRequestOptions) => Promise<IUniversalSnapshot>;
}
declare const forexClient: (apiKey: string, apiBase?: string, options?: IRequestOptions) => IForexClient;

interface IConditionsQuery extends IPolygonQuery {
    asset_class?: "stocks" | "options" | "crypto" | "fx";
    data_type?: "trade" | "bbo" | "nbbo";
    id?: string;
    sip?: "CTA" | "UTP" | "OPRA";
    order?: "asc" | "desc";
    limit?: number;
    sort?: string;
}
interface IConditionsResults {
    abbreviation?: string;
    asset_class: string;
    data_types: string[];
    description?: string;
    exchange?: number;
    id: number;
    legacy?: boolean;
    name: string;
    sip_mapping: {
        CTA?: string;
        OPRA?: string;
        UTP?: string;
    };
    type: string;
    update_rules?: {
        consolidated?: {
            updates_high_low: boolean;
            updates_open_close: boolean;
            updates_volume: boolean;
        };
        market_center?: {
            updates_high_low: boolean;
            updates_open_close: boolean;
            updates_volume: boolean;
        };
    };
}
interface IConditions {
    status: string;
    request_id: string;
    count: number;
    previous_url?: string;
    next_url?: string;
    results: IConditionsResults[];
}

interface IExchangesQuery extends IPolygonQuery {
    asset_class?: "stocks" | "options" | "crypto" | "fx";
    locale?: "us" | "global";
}
interface IExchangesResults {
    acronymstring?: string;
    asset_class: string;
    id: number;
    locale: string;
    mic?: string;
    name: string;
    operating_mic?: string;
    participant_id?: string;
    type: string;
    url?: string;
}
interface IExchanges {
    status: string;
    request_id: string;
    count?: number;
    results: IExchangesResults[];
}

interface IMarketHoliday {
    close?: string;
    date?: string;
    exchange?: string;
    name?: string;
    open?: string;
    status?: string;
}

interface IIndicesGroups {
    s_and_p?: string;
    societe_generale?: string;
    cgi?: string;
    msci?: string;
    ftse_russell?: string;
    mstar?: string;
    mstarc?: string;
    cccy?: string;
    nasdaq?: string;
    dow_jones?: string;
}
interface IMarketStatus {
    afterHours?: boolean;
    currencies?: {
        fx?: string;
        crypto?: string;
    };
    earlyhours?: boolean;
    exchanges?: {
        nyse?: string;
        nasdaq?: string;
        otc?: string;
    };
    indicesGroups?: IIndicesGroups;
    market?: string;
    serverTime?: string;
}

interface IOptionsContractQuery extends IPolygonQuery {
    as_of?: string;
}
interface IAdditionalUnderlyings {
    amount: number;
    type: string;
    underlying: string;
}
interface IOptionsContractResults {
    additional_underlyings: IAdditionalUnderlyings[];
    cfi?: string;
    contract_type?: string;
    correction?: string;
    exercise_style?: string;
    expiration_date?: string;
    primary_exchange?: string;
    shares_per_contract?: number;
    strike_price?: number;
    ticker?: string;
    underlying_ticker?: string;
}
interface IOptionsContract {
    request_id?: string;
    results?: IOptionsContractResults;
    status?: string;
}

interface IOptionsContractsQuery extends IPolygonQuery {
    ticker?: string;
    underlying_ticker?: string;
    contract_type?: string;
    expiration_date?: string;
    "expiration_date.lt"?: string;
    "expiration_date.lte"?: string;
    "expiration_date.gt"?: string;
    "expiration_date.gte"?: string;
    order?: "asc" | "desc";
    limit?: number;
    sort?: string;
}
interface IOptionsContractsResults {
    cfi?: string;
    contract_type?: string;
    correction?: string;
    exercise_style?: string;
    expiration_date?: string;
    primary_exchange?: string;
    shares_per_contract?: number;
    strike_price?: number;
    ticker?: string;
    underlying_ticker?: string;
}
interface IOptionsContracts {
    status?: string;
    request_id?: string;
    previous_url?: string;
    next_url?: string;
    results?: IOptionsContractsResults[];
}

interface IDividend {
    cash_amount: number;
    declaration_date: string;
    dividend_type: "CD" | "SC" | "LT" | "ST";
    ex_dividend_date: string;
    frequency: number;
    pay_date: string;
    record_date: string;
    ticker: string;
}
interface IDividendsResults {
    next_url?: string;
    request_id?: string;
    results?: IDividend[];
    status?: string;
}
interface IDividendsQuery extends IPolygonQuery {
    ticker?: string;
    "ticker.lt"?: string;
    "ticker.lte"?: string;
    "ticker.gt"?: string;
    "ticker.gte"?: string;
    ex_dividend_date?: string;
    "ex_dividend_date.lt"?: string;
    "ex_dividend_date.lte"?: string;
    "ex_dividend_date.gt"?: string;
    "ex_dividend_date.gte"?: string;
    record_date?: string;
    "record_date.lt"?: string;
    "record_date.lte"?: string;
    "record_date.gt"?: string;
    "record_date.gte"?: string;
    declaration_date?: string;
    "declaration_date.lt"?: string;
    "declaration_date.lte"?: string;
    "declaration_date.gt"?: string;
    "declaration_date.gte"?: string;
    pay_date?: string;
    "pay_date.lt"?: string;
    "pay_date.lte"?: string;
    "pay_date.gt"?: string;
    "pay_date.gte"?: string;
    frequency?: 0 | 1 | 2 | 4 | 12;
    cash_amount?: string;
    "cash_amount.lt"?: string;
    "cash_amount.lte"?: string;
    "cash_amount.gt"?: string;
    "cash_amount.gte"?: string;
    dividend_type?: "CD" | "SC" | "LT" | "ST";
    order?: "asc" | "desc";
    limit?: number;
    sort?: "ex_dividend_date" | "pay_date" | "declaration_date" | "record_date" | "cash_amount" | "ticker";
}

interface IStockSplit {
    execution_date?: string;
    split_from: number;
    split_to: number;
    ticker?: string;
}
interface IStockSplitsResults {
    next_url?: string;
    request_id?: string;
    results?: IStockSplit[];
    status?: string;
}
interface IStockSplitsQuery extends IPolygonQuery {
    ticker?: string;
    "ticker.lt"?: string;
    "ticker.lte"?: string;
    "ticker.gt"?: string;
    "ticker.gte"?: string;
    execution_date?: string;
    "execution_date.lt"?: string;
    "execution_date.lte"?: string;
    "execution_date.gt"?: string;
    "execution_date.gte"?: string;
    reverse_split?: "true" | "false";
    order?: "asc" | "desc";
    limit?: number;
    sort?: "ticker" | "execution_date";
}

interface ITableInfo {
    formula?: string;
    label: string;
    order: number;
    unit: string;
    value: number;
    xpath?: string;
}
interface IFinancials {
    balance_sheet?: {
        [key: string]: ITableInfo;
    };
    cash_flow_statement?: {
        [key: string]: ITableInfo;
    };
    comprehensive_income?: {
        [key: string]: ITableInfo;
    };
    income_statement?: {
        [key: string]: ITableInfo;
    };
}
interface IStocksFinancial {
    cik: string;
    company_name: string;
    end_date: string;
    filing_date: string;
    financials: IFinancials;
    fiscal_period: string;
    fiscal_year: string;
    source_filing_file_url: string;
    source_filing_url: string;
    start_date: string;
}
interface IStockFinancialResults {
    count?: number;
    next_url?: string;
    request_id?: string;
    results?: IStocksFinancial[];
    status?: string;
}
interface IStockFinancialQuery extends IPolygonQuery {
    ticker?: string;
    "ticker.lt"?: string;
    "ticker.lte"?: string;
    "ticker.gt"?: string;
    "ticker.gte"?: string;
    cik?: string;
    company_name?: string;
    "company_name.lt"?: string;
    "company_name.lte"?: string;
    "company_name.gt"?: string;
    "company_name.gte"?: string;
    sic?: string;
    filing_date?: string;
    "filing_date.lt"?: string;
    "filing_date.lte"?: string;
    "filing_date.gt"?: string;
    "filing_date.gte"?: string;
    period_of_report_date?: string;
    "period_of_report_date.lt"?: string;
    "period_of_report_date.lte"?: string;
    "period_of_report_date.gt"?: string;
    "period_of_report_date.gte"?: string;
    timeframe?: "annual" | "quarterly" | "ttm";
    included_sources?: "true" | "false";
    order?: "asc" | "desc";
    limit?: number;
    sort?: "filing_date" | "period_of_report_date";
}

interface ITickerDetails {
    request_id?: string;
    results?: {
        active?: boolean;
        address?: {
            address1?: string;
            city?: string;
            state?: string;
            postal_code?: string;
        };
        branding?: {
            icon_url?: string;
            logo_url?: string;
        };
        cik?: number;
        composite_figi?: string;
        currency_name?: string;
        description?: string;
        homepage_url?: string;
        list_date?: string;
        locale?: string;
        market?: string;
        market_cap?: number;
        name?: string;
        phone_number?: string;
        primary_exchange?: string;
        round_lot?: number;
        share_class_figi?: string;
        share_class_shares_outstanding?: number;
        sic_code?: number;
        sic_description?: string;
        ticker?: string;
        ticker_root?: string;
        total_employees?: number;
        type?: string;
        weighted_shares_outstanding?: number;
        source_feed?: string;
    };
    status?: string;
}

declare type TickerTypes = "CS" | "ADRC" | "ADRP" | "ADRR" | "UNIT" | "RIGHT" | "PFD" | "FUND" | "SP" | "WARRENT" | "INDEX" | "ETF" | "ETN";
declare type MarketType = "stocks" | "crypto" | "fx" | "otc" | "indices";
declare type Order = "asc" | "desc";
interface ITickersQuery extends IPolygonQuery {
    ticker?: string;
    "ticker.lt"?: string;
    "ticker.lte"?: string;
    "ticker.gt"?: string;
    "ticker.gte"?: string;
    type?: TickerTypes;
    market?: MarketType;
    exchange?: string;
    cusip?: string;
    cik?: string;
    date?: string;
    search?: string;
    active?: "true" | "false";
    sort?: string;
    order?: Order;
    limit?: number;
    cursor?: string;
}
interface ITickersResults {
    ticker: string;
    name: string;
    market: MarketType;
    locale: string;
    primary_exchange: string;
    type: string;
    active: boolean;
    currency_symbol?: string;
    currency_name?: string;
    base_currency_symbol?: string;
    base_currency_name?: string;
    cik?: string;
    composite_figi?: string;
    share_class_fig?: string;
    last_updated_utc?: string;
    deslisted_utc?: string;
}
interface ITickers {
    status: string;
    request_id: string;
    count: number;
    previous_url?: string;
    next_url?: string;
    results: ITickersResults[];
}

declare type Publisher = {
    favicon_url?: string;
    homepage_url?: string;
    logo_url?: string;
    name?: string;
};
interface ITickerNewsQuery extends IPolygonQuery {
    ticker?: string;
    "ticker.lt"?: string;
    "ticker.lte"?: string;
    "ticker.gt"?: string;
    "ticker.gte"?: string;
    published_utc?: string;
    order?: Order;
    limit?: number;
    sort?: string;
}
interface ITickerNewsResults {
    amp_url?: string;
    article_url?: string;
    author?: string;
    description?: string;
    id: string;
    image_url?: string;
    keywords?: string[];
    published_utc: string;
    publisher: Publisher;
    tickers: string[];
    title: string;
}
interface ITickerNews {
    status: string;
    request_id: string;
    count: number;
    previous_url?: string;
    next_url?: string;
    results: ITickerNewsResults[];
}

declare type AssetClassType = "stocks" | "options" | "crypto" | "fx";
declare type LocaleType = "us" | "global";
interface ITickerTypesQuery extends IPolygonQuery {
    asset_class?: AssetClassType;
    locale?: LocaleType;
}
interface ITickerTypesResults {
    asset_class: AssetClassType;
    code: string;
    description: string;
    locale: LocaleType;
}
interface ITickerTypes {
    status: string;
    request_id: string;
    count?: number;
    results?: ITickerTypesResults[];
}

interface IReferenceClient {
    conditions: (query?: IConditionsQuery, options?: IRequestOptions) => Promise<IConditions>;
    exchanges: (query?: IExchangesQuery, options?: IRequestOptions) => Promise<IExchanges>;
    marketHolidays: (query?: IPolygonQuery, options?: IRequestOptions) => Promise<IMarketHoliday[]>;
    marketStatus: (query?: IPolygonQuery, options?: IRequestOptions) => Promise<IMarketStatus>;
    optionsContract: (optionsTicker: string, query?: IOptionsContractQuery, options?: IRequestOptions) => Promise<IOptionsContract>;
    optionsContracts: (query?: IOptionsContractsQuery, options?: IRequestOptions) => Promise<IOptionsContracts>;
    dividends: (query?: IDividendsQuery, options?: IRequestOptions) => Promise<IDividendsResults>;
    stockSplits: (query?: IStockSplitsQuery, options?: IRequestOptions) => Promise<IStockSplitsResults>;
    stockFinancials: (query?: IStockFinancialQuery, options?: IRequestOptions) => Promise<IStockFinancialResults>;
    tickerDetails: (symbol: string, query?: IPolygonQuery, options?: IRequestOptions) => Promise<ITickerDetails>;
    tickerNews: (query?: ITickerNewsQuery, options?: IRequestOptions) => Promise<ITickerNews>;
    tickers: (query?: ITickersQuery, options?: IRequestOptions) => Promise<ITickers>;
    tickerTypes: (query?: ITickerTypesQuery, options?: IRequestOptions) => Promise<ITickerTypes>;
}
declare const referenceClient: (apiKey: string, apiBase?: string, options?: IRequestOptions) => IReferenceClient;

interface IOptionsDailyOpenCloseQuery extends IPolygonQuery {
    adjusted?: "true" | "false";
}
interface IOptionsDailyOpenClose {
    afterHours?: number;
    close?: number;
    from?: string;
    high?: number;
    low?: number;
    open?: number;
    preMarket?: number;
    status?: string;
    symbol?: string;
    volume?: number;
}

interface IOptionTradesInfo {
    conditions: number[];
    correction: number;
    exchange: number;
    participant_timestamp: number;
    price: number;
    sip_timestamp: number;
    size: number;
}
interface IOptionTrades {
    next_url?: string;
    request_id?: string;
    results?: IOptionTradesInfo[];
    status?: string;
}

interface ILastTradeInfo {
    T?: string;
    f?: string;
    q?: string;
    t?: string;
    y?: string;
    P?: number;
    S?: number;
    X?: number;
    c?: number[];
    e?: number;
    i?: string;
    p?: number;
    r?: number;
    s?: number;
    x?: number;
    z?: number;
}
interface ILastTrade {
    request_id?: string;
    status: string;
    results?: ILastTradeInfo;
}

interface IOptionsLastTrade {
    request_id?: string;
    status?: string;
    results?: ILastTradeInfo;
}

interface IOptionQuotesInfo {
    ask_exchange: number;
    ask_price: number;
    ask_size: number;
    bid_exchange: number;
    bid_price: number;
    bid_size: number;
    sequence_number: number;
    sip_timestamp: number;
}
interface IOptionQuotes {
    next_url?: string;
    request_id?: string;
    results?: IOptionQuotesInfo[];
    status?: string;
}

interface SnapshotDay$1 {
    change?: number;
    change_percent?: number;
    close?: number;
    high?: number;
    last_updated?: number;
    low?: number;
    open?: number;
    previous_close?: number;
    volume?: number;
    vwap?: number;
}
interface SnapshotDetails {
    contract_type?: string;
    exercise_styled?: string;
    expiration_date?: string;
    shares_per_contract?: number;
    strike_price?: number;
    ticker?: string;
}
interface SnapshotGreeks {
    delta?: number;
    gamma?: number;
    theta?: number;
    vega?: number;
}
interface SnapshotLastQuote$1 {
    ask?: number;
    ask_size?: number;
    bid?: number;
    bid_size?: number;
    last_updated?: number;
    midpoint?: number;
    timeframe?: number;
}
interface SnapshotLastTrade$1 {
    conditions?: number[];
    exchange?: number;
    price?: number;
    sip_timestamp?: number;
    size?: number;
    timeframe?: string;
}
interface SnapshotUnderlyingAsset {
    change_to_break_even?: number;
    last_updated?: number;
    price?: number;
    ticker?: string;
    timeframe?: string;
    value?: number;
}
interface SnapshotInfo$1 {
    break_even_price?: number;
    day?: SnapshotDay$1;
    details?: SnapshotDetails;
    greeks?: SnapshotGreeks;
    implied_volatility?: number;
    last_quote?: SnapshotLastQuote$1;
    last_trade?: SnapshotLastTrade$1;
    open_interest?: number;
    underlying_asset?: SnapshotUnderlyingAsset;
}
interface IOptionsSnapshotContract {
    status?: string;
    request_id?: string;
    previous_url?: string;
    next_url?: string;
    results?: SnapshotInfo$1;
}
interface IOptionsSnapshotChain {
    status?: string;
    request_id?: string;
    next_url?: string;
    results?: SnapshotInfo$1[];
}
interface IOptionsChainQuery extends IPolygonQuery {
    contract_type?: "call" | "put";
    expiration_date?: string;
    "expiration_date.lt"?: string;
    "expiration_date.lte"?: string;
    "expiration_date.gt"?: string;
    "expiration_date.gte"?: string;
    order?: "asc" | "desc";
    limit?: number;
    sort?: "ticker" | "expiration_date" | "strike_price";
    strike_price?: number;
    "strike_price.lt"?: number;
    "strike_price.lte"?: number;
    "strike_price.gt"?: number;
    "strike_price.gte"?: number;
}
declare const snapshotOptionChain: (get: IGet, underlyingAsset: string, query?: IOptionsChainQuery, options?: IRequestOptions) => Promise<IOptionsSnapshotChain>;
declare const snapshotOptionContract: (get: IGet, underlyingAsset: string, optionContract: string, query?: IOptionsChainQuery, options?: IRequestOptions) => Promise<IOptionsSnapshotContract>;

interface IOptionsClient {
    aggregates: (ticker: string, multiplier: number, timespan: string, from: string, to: string, query?: IAggsQuery, options?: IRequestOptions) => Promise<IAggs>;
    summaries: (query?: ISummariesQuery, options?: IRequestOptions) => Promise<ISummaries>;
    dailyOpenClose: (symbol: string, date: string, query?: IOptionsDailyOpenCloseQuery, options?: IRequestOptions) => Promise<IOptionsDailyOpenClose>;
    previousClose: (symbol: string, query?: IAggsPreviousCloseQuery, options?: IRequestOptions) => Promise<IAggsPreviousClose>;
    trades: (optionsTicker: string, query?: ITradesQuotesQuery, options?: IRequestOptions) => Promise<IOptionTrades>;
    lastTrade: (symbol: string, query?: IPolygonQuery, options?: IRequestOptions) => Promise<IOptionsLastTrade>;
    quotes: (optionsTicker: string, query?: ITradesQuotesQuery, options?: IRequestOptions) => Promise<IOptionQuotes>;
    snapshotOptionContract: (underlyingAsset: string, optionContract: string, query?: IPolygonQuery, options?: IRequestOptions) => Promise<IOptionsSnapshotContract>;
    snapshotOptionChain: (underlyingAsset: string, query?: IOptionsChainQuery, options?: IRequestOptions) => Promise<IOptionsSnapshotChain>;
    sma: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<ISma>;
    ema: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IEma>;
    macd: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IMacd>;
    rsi: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IRsi>;
    universalSnapshot: (query?: IUniversalSnapshotQuery, options?: IRequestOptions) => Promise<IUniversalSnapshot>;
}
declare const optionsClient: (apiKey: string, apiBase?: string, options?: IRequestOptions) => IOptionsClient;

interface IDailyOpenCloseQuery extends IPolygonQuery {
    adjusted?: "true" | "false";
}
interface IDailyOpenClose {
    afterHours?: number;
    close?: number;
    from?: string;
    high?: number;
    low?: number;
    open?: number;
    preMarket?: number;
    status?: string;
    symbol?: string;
    volume?: number;
}

interface ILastQuote {
    request_id?: string;
    status?: string;
    results?: ILastTradeInfo;
}

interface SnapshotDay {
    c?: number;
    h?: number;
    l?: number;
    o?: number;
    v?: number;
    vw?: number;
}
interface SnapshotLastQuote {
    P?: number;
    S?: number;
    p?: number;
    s?: number;
    t?: number;
}
interface SnapshotLastTrade {
    c?: string[];
    i?: string;
    p?: number;
    s?: number;
    t?: number;
    x?: number;
}
interface SnapshotMin {
    av?: number;
    c?: number;
    h?: number;
    l?: number;
    o?: number;
    v?: number;
    vw?: number;
}
interface SnapshotPrevDay {
    c?: number;
    h?: number;
    l?: number;
    o?: number;
    v?: number;
    vw?: number;
    t?: number;
    n?: number;
}
interface SnapshotInfo {
    day?: SnapshotDay;
    lastQuote?: SnapshotLastQuote;
    lastTrade?: SnapshotLastTrade;
    min?: SnapshotMin;
    prevDay?: SnapshotPrevDay;
    ticker?: string;
    todaysChange?: number;
    todaysChangePerc?: number;
    updated?: number;
}
interface ISnapshotAllTickersQuery extends IPolygonQuery {
    tickers?: string;
}
interface ISnapshotTickers {
    count?: number;
    status?: string;
    tickers?: SnapshotInfo[];
}
interface ISnapshot {
    status?: string;
    request_id?: string;
    ticker?: SnapshotInfo;
}

interface IQuotesInfo {
    ask_exchange: number;
    ask_price: number;
    ask_size: number;
    bid_exchange: number;
    bid_price: number;
    bid_size: number;
    conditions: number[];
    indicators: number[];
    participant_timestamp: number;
    sequence_number: number;
    sip_timestamp: number;
    tape: number;
    trf_timestamp: number;
}
interface IQuotes {
    next_url?: string;
    request_id?: string;
    results?: IQuotesInfo[];
    status?: string;
}

interface IStocksClient {
    aggregates: (ticker: string, multiplier: number, timespan: string, from: string, to: string, query?: IAggsQuery, options?: IRequestOptions) => Promise<IAggs>;
    aggregatesGroupedDaily: (date: string, query?: IAggsGroupedDailyQuery, options?: IRequestOptions) => Promise<IAggsGroupedDaily>;
    summaries: (query?: ISummariesQuery, options?: IRequestOptions) => Promise<ISummaries>;
    dailyOpenClose: (symbol: string, date: string, query?: IDailyOpenCloseQuery, options?: IRequestOptions) => Promise<IDailyOpenClose>;
    lastQuote: (symbol: string, query?: IPolygonQuery, options?: IRequestOptions) => Promise<ILastQuote>;
    lastTrade: (symbol: string, query?: IPolygonQuery, options?: IRequestOptions) => Promise<ILastTrade>;
    previousClose: (ticker: string, query?: IAggsPreviousCloseQuery, options?: IRequestOptions) => Promise<IAggsPreviousClose>;
    quotes: (stockTicker: string, query?: ITradesQuotesQuery, options?: IRequestOptions) => Promise<IQuotes>;
    snapshotAllTickers: (query?: ISnapshotAllTickersQuery, options?: IRequestOptions) => Promise<ISnapshotTickers>;
    snapshotGainersLosers: (direction: "gainers" | "losers", query?: IPolygonQuery, options?: IRequestOptions) => Promise<ISnapshotTickers>;
    snapshotTicker: (symbol: string, query?: IPolygonQuery, options?: IRequestOptions) => Promise<ISnapshot>;
    sma: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<ISma>;
    ema: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IEma>;
    macd: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IMacd>;
    rsi: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IRsi>;
    trades: (stockTicker: string, query?: ITradesQuotesQuery, options?: IRequestOptions) => Promise<ITrades>;
    universalSnapshot: (query?: IUniversalSnapshotQuery, options?: IRequestOptions) => Promise<IUniversalSnapshot>;
}
declare const stocksClient: (apiKey: string, apiBase?: string, options?: IRequestOptions) => IStocksClient;

interface IIndexSnapshotSession {
    change?: number;
    change_percent?: number;
    close?: number;
    high?: number;
    low?: number;
    open?: number;
    previous_close?: number;
}
interface IIndexSnapshotInfo {
    market_status: string;
    name: string;
    session: IIndexSnapshotSession;
    ticker: string;
    type: string;
    value: number;
}
interface IIndexSnapshot {
    status?: string;
    request_id?: string;
    index?: IIndexSnapshotInfo;
}

interface IIndicesClient {
    aggregates: (ticker: string, multiplier: number, timespan: string, from: string, to: string, query?: IAggsQuery, options?: IRequestOptions) => Promise<IAggs>;
    dailyOpenClose: (symbol: string, date: string, query?: IDailyOpenCloseQuery, options?: IRequestOptions) => Promise<IDailyOpenClose>;
    previousClose: (ticker: string, query?: IAggsPreviousCloseQuery, options?: IRequestOptions) => Promise<IAggsPreviousClose>;
    snapshotTicker: (query?: IPolygonQuery, options?: IRequestOptions) => Promise<IIndexSnapshot>;
    sma: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<ISma>;
    ema: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IEma>;
    macd: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IMacd>;
    rsi: (symbol: string, query?: ITechnicalIndicatorsQuery, options?: IRequestOptions) => Promise<IRsi>;
}
declare const indicesClient: (apiKey: string, apiBase?: string, options?: IRequestOptions) => IIndicesClient;

interface IRestClient {
    crypto: ICryptoClient;
    forex: IForexClient;
    reference: IReferenceClient;
    options: IOptionsClient;
    stocks: IStocksClient;
    indices: IIndicesClient;
}
declare const restClient: (apiKey: any, apiBase?: string, options?: IRequestOptions) => IRestClient;

interface IAggegateForexEvent {
    ev: string;
    pair: string;
    o: number;
    c: number;
    h: number;
    l: number;
    v: number;
    s: number;
    e: number;
}
interface IQuoteForexEvent {
    ev: string;
    p: string;
    x: string;
    a: number;
    b: number;
    t: number;
}
declare const getForexWebsocket: (apiKey: string, apiBase?: string) => websocket.w3cwebsocket;

interface IAggregateIndexEvent {
    ev: string;
    sym: string;
    o: number;
    op: number;
    c: number;
    h: number;
    l: number;
    s: number;
    e: number;
}
interface IIndexValueEvent {
    ev: string;
    val: string;
    T: string;
    t: number;
}
declare const getIndicesWebsocket: (apiKey: string, apiBase?: string) => websocket.w3cwebsocket;

interface IAggregateStockEvent {
    ev: string;
    sym: string;
    v: number;
    av: number;
    op: number;
    vw: number;
    o: number;
    c: number;
    h: number;
    l: number;
    a: number;
    z: number;
    s: number;
    e: number;
}
interface ITradeStockEvent {
    ev: string;
    sym: string;
    x: string;
    i: number;
    z: number;
    p: number;
    s: number;
    c: number[];
    t: number;
}
interface IQuoteStockEvent {
    ev: string;
    sym: string;
    bx: string;
    bp: number;
    bs: number;
    ax: string;
    ap: number;
    as: number;
    c: number;
    t: number;
    z: number;
}
declare const getStocksWebsocket: (apiKey: string, apiBase?: string) => websocket.w3cwebsocket;

interface IAggregateCryptoEvent {
    ev: string;
    pair: string;
    o: number;
    c: number;
    h: number;
    l: number;
    v: number;
    s: number;
    e: number;
}
interface ITradeCryptoEvent {
    ev: string;
    pair: string;
    p: number;
    t: number;
    s: number;
    c: number[];
    i: string;
    x: number;
    r: number;
}
interface IQuoteCryptoEvent {
    ev: string;
    pair: string;
    bp: number;
    bs: number;
    ap: number;
    as: number;
    t: number;
    x: number;
    r: number;
}
interface ILevel2CryptoEvent {
    ev: string;
    pair: string;
    b: any[];
    a: any[];
    t: number;
    x: number;
    r: number;
}
declare const getCryptoWebsocket: (apiKey: string, apiBase?: string) => websocket.w3cwebsocket;

interface IAggregateOptionsEvent {
    ev: string;
    sym: string;
    v: number;
    av: number;
    op: number;
    vw: number;
    o: number;
    c: number;
    h: number;
    l: number;
    a: number;
    z: number;
    s: number;
    e: number;
}
interface ITradeOptionsEvent {
    ev: string;
    sym: string;
    x: string;
    p: number;
    s: number;
    c: number[];
    t: number;
    q: number;
}
declare type IQuoteOptionsEvent = {
    ev: string;
    sym: string;
    bx: number;
    ax: number;
    bp: number;
    ap: number;
    bs: number;
    as: number;
    t: number;
    q: number;
};
declare const getOptionsWebsocket: (apiKey: string, apiBase?: string) => websocket.w3cwebsocket;

interface IWebsocketClient {
    crypto: () => websocket.w3cwebsocket;
    forex: () => websocket.w3cwebsocket;
    indices: () => websocket.w3cwebsocket;
    options: () => websocket.w3cwebsocket;
    stocks: () => websocket.w3cwebsocket;
}
declare const websocketClient: (apiKey: string, apiBase?: string) => IWebsocketClient;

interface IPolygonClient {
    rest: IRestClient;
    websockets: IWebsocketClient;
}
declare const polygonClient: (apiKey: string, restApiBase?: string, websocketApiBase?: string) => IPolygonClient;

export { IAggegateForexEvent, IAggregateCryptoEvent, IAggregateIndexEvent, IAggregateOptionsEvent, IAggregateStockEvent, IAggs, IAggsGroupedDaily, IAggsGroupedDailyQuery, IAggsPreviousClose, IAggsPreviousCloseQuery, IAggsQuery, IConditions, IConversion, IConversionQuery, ICryptoClient, ICryptoDailyOpenClose, ICryptoDailyOpenCloseQuery, ICryptoLastTrade, ICryptoSnapshot, ICryptoSnapshotAllTickersQuery, ICryptoSnapshotFullBookL2, ICryptoSnapshotTickers, ICryptoTrade, ICurriedGet, IDailyOpenClose, IDailyOpenCloseQuery, IDividendsResults, IEma, IExchanges, IForexClient, IForexLastQuote, IForexQuotes, IForexSnapshot, IForexSnapshotAllTickersQuery, IForexSnapshotTickers, IGet, IGlobalOptions, IHeaders, IIndexValueEvent, IIndicesClient, ILastQuote, ILastTrade, ILevel2CryptoEvent, IMacd, IMarketHoliday, IMarketStatus, IOptionQuotes, IOptionTrades, IOptionsChainQuery, IOptionsClient, IOptionsDailyOpenClose, IOptionsDailyOpenCloseQuery, IOptionsLastTrade, IOptionsSnapshotChain, IOptionsSnapshotContract, IPolygonClient, IPolygonEdgeHeaders, IPolygonQuery, IPolygonQueryWithCredentials, IQuoteCryptoEvent, IQuoteForexEvent, IQuoteOptionsEvent, IQuoteStockEvent, IQuotes, IRealTimeCurrencyConversion, IRealTimeCurrencyConversionQuery, IReferenceClient, IRequestInit, IRequestOptions, IRestClient, IRsi, ISma, ISnapshot, ISnapshotAllTickersQuery, ISnapshotTickers, IStockFinancialResults, IStockSplitsResults, IStocksClient, IStructuredError, ISummaries, ISummariesQuery, ITechnicalIndicatorsQuery, ITickerDetails, ITickerNews, ITickerNewsQuery, ITickerTypes, ITickerTypesQuery, ITickers, ITickersQuery, ITradeCryptoEvent, ITradeOptionsEvent, ITradeStockEvent, ITrades, ITradesQuotesQuery, IUniversalSnapshot, IUniversalSnapshotQuery, IWebsocketClient, UniversalSnapshotDetails, UniversalSnapshotGreeks, UniversalSnapshotInfo, UniversalSnapshotLastQuote, UniversalSnapshotLastTrade, UniversalSnapshotSession, UniversalSnapshotUnderlyingAsset, cryptoClient, polygonClient as default, forexClient, getCryptoWebsocket, getForexWebsocket, getIndicesWebsocket, getOptionsWebsocket, getStocksWebsocket, getWithGlobals, indicesClient, optionsClient, polygonClient, referenceClient, restClient, snapshotOptionChain, snapshotOptionContract, stocksClient, universalSnapshot, websocketClient };