@master-chief/alpaca/@types/entities.d.ts

export interface Endpoints {
    rest: {
        beta: 'https://data.alpaca.markets/v1beta1';
        account: 'https://api.alpaca.markets/v2';
        market_data_v2: 'https://data.alpaca.markets/v2';
        market_data_v1: 'https://data.alpaca.markets/v1';
    };
    websocket: {
        account: 'wss://api.alpaca.markets/stream';
        market_data: (source: DataSource) => string;
    };
}
/**
 * Your Alpaca key id and secret.
 * Can be passed to the AlpacaClient and AlpacaStream.
 */
export interface DefaultCredentials {
    key: string;
    secret: string;
    paper?: boolean;
}
/**
 * Client ID for Oauth requests on behalf of users.
 * Can be passed to the AlpacaClient.
 */
export interface OAuthCredentials {
    access_token: String;
    paper?: boolean;
}
/**
 * The account information with unparsed types, exactly as Alpaca provides it.
 * We encourage you to use the Account interface, which has many of these fields parsed.
 */
export interface RawAccount {
    account_blocked: boolean;
    account_number: string;
    buying_power: string;
    cash: string;
    created_at: string;
    currency: string;
    daytrade_count: number;
    daytrading_buying_power: string;
    equity: string;
    id: string;
    initial_margin: string;
    last_equity: string;
    last_maintenance_margin: string;
    long_market_value: string;
    maintenance_margin: string;
    multiplier: string;
    pattern_day_trader: boolean;
    portfolio_value: string;
    regt_buying_power: string;
    short_market_value: string;
    shorting_enabled: boolean;
    sma: string;
    status: string;
    trade_suspended_by_user: boolean;
    trading_blocked: boolean;
    transfers_blocked: boolean;
}
/**
 * The following are the possible account status values. Most likely, the account status
 * is ACTIVE unless there is any problem. The account status may get in ACCOUNT_UPDATED
 * when personal information is being updated from the dashboard, in which case you may
 * not be allowed trading for a short period of time until the change is approved.
 */
export declare type AccountStatus = 
/**
 * The account is onboarding.
 */
'ONBOARDING'
/**
 * The account application submission failed for some reason.
 */
 | 'SUBMISSION_FAILED'
/**
 * The account application has been submitted for review.
 */
 | 'SUBMITTED'
/**
 * The account information is being updated.
 */
 | 'ACCOUNT_UPDATED'
/**
 * The final account approval is pending.
 */
 | 'APPROVAL_PENDING'
/**
 * The account is active for trading.
 */
 | 'ACTIVE'
/**
 * The account application has been rejected.
 */
 | 'REJECTED';
/**
 * Information related to an Alpaca account, such as account status, funds, and various
 * flags relevant to an account's ability to trade.
 */
export interface Account {
    /**
     * Get the raw data, exactly as it came from Alpaca
     */
    raw(): RawAccount;
    /**
     * If true, the account activity by user is prohibited.
     */
    account_blocked: boolean;
    /**
     * Account number.
     */
    account_number: string;
    /**
     * Current available $ buying power; If multiplier = 4, this is your daytrade buying
     * power which is calculated as (last_equity - (last) maintenance_margin) * 4; If
     * multiplier = 2, buying_power = max(equity – initial_margin,0) * 2; If multiplier = 1,
     * buying_power = cash
     */
    buying_power: number;
    /**
     * Cash balance
     */
    cash: number;
    /**
     * Timestamp this account was created at
     */
    created_at: Date;
    /**
     * "USD"
     */
    currency: string;
    /**
     * The current number of daytrades that have been made in the last 5 trading days
     * (inclusive of today)
     */
    daytrade_count: number;
    /**
     * Your buying power for day trades (continuously updated value)
     */
    daytrading_buying_power: number;
    /**
     * Cash + long_market_value + short_market_value
     */
    equity: number;
    /**
     * Account ID.
     */
    id: string;
    /**
     * Reg T initial margin requirement (continuously updated value)
     */
    initial_margin: number;
    /**
     * Equity as of previous trading day at 16:00:00 ET
     */
    last_equity: number;
    /**
     * Your maintenance margin requirement on the previous trading day
     */
    last_maintenance_margin: number;
    /**
     * Real-time MtM value of all long positions held in the account
     */
    long_market_value: number;
    /**
     * Maintenance margin requirement (continuously updated value)
     */
    maintenance_margin: number;
    /**
     * Buying power multiplier that represents account margin classification; valid values 1
     * (standard limited margin account with 1x buying power), 2 (reg T margin account with
     * 2x intraday and overnight buying power; this is the default for all non-PDT accounts
     * with $2,000 or more equity), 4 (PDT account with 4x intraday buying power and 2x reg
     * T overnight buying power)
     */
    multiplier: number;
    /**
     * Whether or not the account has been flagged as a pattern day trader
     */
    pattern_day_trader: boolean;
    /**
     * Total value of cash + holding positions (This field is deprecated. It is equivalent
     * to the equity field.)
     */
    portfolio_value: number;
    /**
     * Your buying power under Regulation T (your excess equity - equity minus margin
     * value - times your margin multiplier)
     */
    regt_buying_power: number;
    /**
     * Real-time MtM value of all short positions held in the account
     */
    short_market_value: number;
    /**
     * Flag to denote whether or not the account is permitted to short
     */
    shorting_enabled: boolean;
    /**
     * Value of special memorandum account (will be used at a later date to provide
     * additional buying_power)
     */
    sma: number;
    /**
     * The following are the possible account status values. Most likely, the account status
     * is ACTIVE unless there is any problem. The account status may get in ACCOUNT_UPDATED
     * when personal information is being updated from the dashboard, in which case you may
     * not be allowed trading for a short period of time until the change is approved.
     */
    status: AccountStatus;
    /**
     * User setting. If true, the account is not allowed to place orders.
     */
    trade_suspended_by_user: boolean;
    /**
     * If true, the account is not allowed to place orders.
     */
    trading_blocked: boolean;
    /**
     * If true, the account is not allowed to request money transfers.
     */
    transfers_blocked: boolean;
}
export interface AccountConfigurations {
    /**
     * both, entry, or exit. Controls Day Trading Margin Call (DTMC) checks.
     */
    dtbp_check: 'both' | 'entry' | 'exit';
    /**
     * If true, account becomes long-only mode.
     */
    no_shorting: boolean;
    /**
     * If true, new orders are blocked.
     */
    suspend_trade: boolean;
    /**
     * all or none. If none, emails for order fills are not sent.
     */
    trade_confirm_email: 'all' | 'none';
}
export interface AccountUpdate {
    id: string;
    created_at: string;
    updated_at: string;
    deleted_at: any;
    status: string;
    currency: string;
    cash: string;
    cash_withdrawable: string;
}
export interface AggregateMinute {
    ev: string;
    T: string;
    v: number;
    av: number;
    op: number;
    vw: number;
    o: number;
    c: number;
    h: number;
    l: number;
    a: number;
    s: number;
    e: number;
}
export declare type AssetExchange = 'AMEX' | 'ARCA' | 'BATS' | 'NYSE' | 'NASDAQ' | 'NYSEARCA';
export declare type AssetStatus = 'active' | 'inactive';
/**
 * The assets API serves as the master list of assets available for trade and data
 * consumption from Alpaca. Assets are sorted by asset class, exchange and symbol. Some
 * assets are only available for data consumption via Polygon, and are not tradable with
 * Alpaca. These assets will be marked with the flag tradable=false.
 */
export interface Asset {
    /**
     * Asset ID
     */
    id: string;
    /**
     * "us_equity"
     */
    class: string;
    /**
     * AMEX, ARCA, BATS, NYSE, NASDAQ or NYSEARCA
     */
    exchange: AssetExchange;
    /**
     * Asset symbol
     */
    symbol: string;
    /**
     * active or inactive
     */
    status: AssetStatus;
    /**
     * Asset is tradable on Alpaca or not
     */
    tradable: boolean;
    /**
     * Asset is marginable or not
     */
    marginable: boolean;
    /**
     * Asset is shortable or not
     */
    shortable: boolean;
    /**
     * Asset is easy-to-borrow or not (filtering for easy_to_borrow = True is the best way
     * to check whether the name is currently available to short at Alpaca).
     */
    easy_to_borrow: boolean;
    /**
     * Asset is fractionable or not.
     */
    fractionable: boolean;
}
/**
 * Contains the time of open and close for a market on a particular day from 1970 to 2029
 */
export interface Calendar {
    /**
     * Date string in YYYY-MM-DD format
     */
    date: string;
    /**
     * The time the market opens at on this date in HH:MM format
     */
    open: string;
    /**
     * The time the market closes at on this date in HH:MM format
     */
    close: string;
}
export interface RawClock {
    timestamp: string;
    is_open: boolean;
    next_open: string;
    next_close: string;
}
/**
 * The clock API serves the current market timestamp, whether or not the market is
 * currently open, as well as the times of the next market open and close.
 */
export interface Clock {
    /**
     * Get the raw data, exactly as it came from Alpaca
     */
    raw(): RawClock;
    /**
     * Current timestamp
     */
    timestamp: Date;
    /**
     * Whether or not the market is open
     */
    is_open: boolean;
    /**
     * Next market open timestamp
     */
    next_open: Date;
    /**
     * Next market close timestamp
     */
    next_close: Date;
}
/** A trade which occurred. */
export interface RawTrade {
    /** Trade symbol. */
    S: string;
    /** Timestamp in RFC-3339 format with nanosecond precision. */
    t: string;
    /** Exchange where the trade happened. */
    x: string;
    /** Trade price. */
    p: number;
    /** Trade size. */
    s: number;
    /** Trade conditions. */
    c: string[];
    /** Trade ID. */
    i: number;
    /** Tape. */
    z: string;
}
/** A page of one or many trades. */
export interface RawPageOfTrades {
    /** Array of trades. */
    trades: RawTrade[];
    /** Symbol that was queried. */
    symbol: string;
    /** Token that can be used to query the next page. */
    next_page_token: string;
}
/** A trade which occurred. */
export interface Trade {
    /** Get the raw data as it came from Alpaca. */
    raw(): RawTrade;
    /** Trade symbol. */
    S: string;
    /** Timestamp in RFC-3339 format with nanosecond precision. */
    t: Date;
    /** Exchange where the trade happened. */
    x: string;
    /** Trade price. */
    p: number;
    /** Trade size. */
    s: number;
    /** Trade conditions. */
    c: string[];
    /** Trade ID. */
    i: number;
    /** Tape. */
    z: string;
}
/** A page of one or many trades. */
export interface PageOfTrades {
    /** Get the raw data as it came from Alpaca. */
    raw(): RawPageOfTrades;
    /** Array of trades. */
    trades: Trade[];
    /** Symbol that was queried. */
    symbol: string;
    /** Token that can be used to query the next page. */
    next_page_token: string;
}
/** A quote for a symbol. */
export interface RawQuote {
    /** Quote symbol. */
    S: string;
    /** Timestamp in RFC-3339 format with nanosecond precision. */
    t: string;
    /** Ask exchange. */
    ax: string;
    /** Ask price. */
    ap: number;
    /** Ask size. */
    as: number;
    /** Bid exchange. */
    bx: string;
    /** Bid price. */
    bp: number;
    /** Bid size. */
    bs: number;
    /** Quote conditions. */
    c: string[];
}
/** A page of one or many quotes. */
export interface RawPageOfQuotes {
    /** Array of quotes. */
    quotes: RawQuote[];
    /** Symbol that was queried. */
    symbol: string;
    /** Token that can be used to query the next page. */
    next_page_token: string;
}
/** A quote for a symbol. */
export interface Quote {
    /** Get the raw data as it came from Alpaca. */
    raw(): RawQuote;
    /** Quote symbol. */
    S: string;
    /** Timestamp in Date format. */
    t: Date;
    /** Ask exchange. */
    ax: string;
    /** Ask price. */
    ap: number;
    /** Ask size. */
    as: number;
    /** Bid exchange. */
    bx: string;
    /** Bid price. */
    bp: number;
    /** Bid size. */
    bs: number;
    /** Quote conditions. */
    c: string[];
}
/** A page of one or many quotes. */
export interface PageOfQuotes {
    /** Get the raw data as it came from Alpaca. */
    raw(): RawPageOfQuotes;
    /** Array of quotes. */
    quotes: Quote[];
    /** Symbol that was queried. */
    symbol: string;
    /** Token that can be used to query the next page. */
    next_page_token: string;
}
/** A bar for a symbol. */
export interface RawBar {
    /** Bar symbol. */
    S: string;
    /** Timestamp in RFC-3339 format with nanosecond precision. */
    t: string;
    /** Open price. */
    o: number;
    /** High price. */
    h: number;
    /** Low price. */
    l: number;
    /** Close price. */
    c: number;
    /** Volume. */
    v: number;
}
/** A page of one or many bars. */
export interface RawPageOfBars {
    /** Array of bars. */
    bars: RawBar[];
    /** Symbol that was queried. */
    symbol: string;
    /** Token that can be used to query the next page. */
    next_page_token: string;
}
/** A bar for a symbol. */
export interface Bar {
    /** Get the raw data as it came from Alpaca. */
    raw(): RawBar;
    /** Bar symbol. */
    S: string;
    /** Timestamp in Date format. */
    t: Date;
    /** Open price. */
    o: number;
    /** High price. */
    h: number;
    /** Low price. */
    l: number;
    /** Close price. */
    c: number;
    /** Volume. */
    v: number;
}
/** A page of one or many bars. */
export interface PageOfBars {
    /** Get the raw data as it came from Alpaca. */
    raw(): RawPageOfBars;
    /** Array of bars. */
    bars: Bar[];
    /** Symbol that was queried. */
    symbol: string;
    /** Token that can be used to query the next page. */
    next_page_token: string;
}
/**
 * The parsed result of an order cancelation request.
 */
export interface OrderCancelation {
    id: string;
    status: number;
    order: Order;
}
/**
 * The id, http status code and order as part of the cancel all orders request.
 */
export interface RawOrderCancelation {
    id: string;
    status: number;
    body: RawOrder;
}
/**
 * The order entity with unparsed fields, exactly as Alpaca provides it.
 * We encourage you to use the Order interface, which has many of these fields parsed.
 */
export interface RawOrder {
    id: string;
    client_order_id: string;
    created_at: string;
    updated_at: string;
    submitted_at: string;
    filled_at: string;
    expired_at: string;
    canceled_at: string;
    failed_at: string;
    replaced_at: string;
    replaced_by: string;
    replaces: string;
    asset_id: string;
    symbol: string;
    asset_class: string;
    qty: string;
    filled_qty: string;
    type: string;
    side: string;
    time_in_force: string;
    limit_price: string;
    stop_price: string;
    filled_avg_price: string;
    status: string;
    extended_hours: boolean;
    legs: RawOrder[];
    trail_price: string;
    trail_percent: string;
    hwm: string;
    order_class?: OrderClass;
}
/**
 * Price and volume data during a particular time interval
 */
export interface Bar_v1 {
    /**
     * the beginning time of this bar as a Unix epoch in seconds
     */
    t: number;
    /**
     * open price
     */
    o: number;
    /**
     * high price
     */
    h: number;
    /**
     * low price
     */
    l: number;
    /**
     * close price
     */
    c: number;
    /**
     * volume
     */
    v: number;
}
/**
 * Last quote details for a symbol
 */
export interface LastQuote_v1 {
    status: string;
    symbol: string;
    last: {
        /**
         * the current ask price
         */
        askprice: number;
        /**
         * the current ask size
         */
        asksize: number;
        /**
         * the exchange code of the ask quote
         */
        askexchange: number;
        /**
         * the current bid price
         */
        bidprice: number;
        /**
         * the current bid size
         */
        bidsize: number;
        /**
         * the exchange code of the bid quote
         */
        bidexchange: number;
        /**
         * epoch timestamp in nanoseconds
         */
        timestamp: number;
    };
}
/**
 * Last trade details for a symbol
 */
export interface LastTrade_v1 {
    status: string;
    symbol: string;
    last: {
        /**
         * last trade price
         */
        price: number;
        /**
         * last trade volume size
         */
        size: number;
        /**
         * exchange code where the last trade was made
         */
        exchange: number;
        /**
         * condition flag 1
         */
        cond1: number;
        /**
         * condition flag 2
         */
        cond2: number;
        /**
         * condition flag 3
         */
        cond3: number;
        /**
         * condition flag 4
         */
        cond4: number;
        /**
         * epoch timestamp in nanoseconds
         */
        timestamp: number;
    };
}
export interface RawSnapshot {
    symbol: string;
    latestTrade: {
        t: string;
        x: string;
        p: number;
        s: number;
        c?: string[] | null;
        i: number;
        z: string;
    };
    latestQuote: {
        t: string;
        ax: string;
        ap: number;
        as: number;
        bx: string;
        bp: number;
        bs: number;
        c?: string[] | null;
    };
    minuteBar: {
        t: string;
        o: number;
        h: number;
        l: number;
        c: number;
        v: number;
    };
    dailyBar: {
        t: string;
        o: number;
        h: number;
        l: number;
        c: number;
        v: number;
    };
    prevDailyBar: {
        t: string;
        o: number;
        h: number;
        l: number;
        c: number;
        v: number;
    };
}
export interface Snapshot {
    /** Get the raw data as it came from Alpaca. */
    raw(): RawSnapshot;
    symbol: string;
    latestTrade: {
        t: Date;
        x: string;
        p: number;
        s: number;
        c?: string[] | null;
        i: number;
        z: string;
    };
    latestQuote: {
        t: Date;
        ax: string;
        ap: number;
        as: number;
        bx: string;
        bp: number;
        bs: number;
        c?: string[] | null;
    };
    minuteBar: {
        t: Date;
        o: number;
        h: number;
        l: number;
        c: number;
        v: number;
    };
    dailyBar: {
        t: Date;
        o: number;
        h: number;
        l: number;
        c: number;
        v: number;
    };
    prevDailyBar: {
        t: Date;
        o: number;
        h: number;
        l: number;
        c: number;
        v: number;
    };
}
export declare type DataSource = 'iex' | 'sip';
export declare type OrderType = 'market' | 'limit' | 'stop' | 'stop_limit' | 'trailing_stop';
export declare type OrderClass = 'simple' | 'bracket' | 'oto' | 'oco';
export declare type OrderSide = 'buy' | 'sell';
export declare type OrderTimeInForce = 
/**
 * A day order is eligible for execution only on the day it is live. By default, the
 * order is only valid during Regular Trading Hours (9:30am - 4:00pm ET). If unfilled
 * after the closing auction, it is automatically canceled. If submitted after the
 * close, it is queued and submitted the following trading day. However, if marked as
 * eligible for extended hours, the order can also execute during supported extended
 * hours.
 */
'day'
/**
 * The order is good until canceled. Non-marketable GTC limit orders are subject to
 * price adjustments to offset corporate actions affecting the issue. We do not
 * currently support Do Not Reduce(DNR) orders to opt out of such price adjustments.
 */
 | 'gtc'
/**
 * Use this TIF with a market/limit order type to submit "market on open" (MOO) and
 * "limit on open" (LOO) orders. This order is eligible to execute only in the market
 * opening auction. Any unfilled orders after the open will be cancelled. OPG orders
 * submitted after 9:28am but before 7:00pm ET will be rejected. OPG orders submitted
 * after 7:00pm will be queued and routed to the following day's opening auction. On
 * open/on close orders are routed to the primary exchange. Such orders do not
 * necessarily execute exactly at 9:30am / 4:00pm ET but execute per the exchange's
 * auction rules.
 */
 | 'opg'
/**
 * Use this TIF with a market/limit order type to submit "market on close" (MOC) and
 * "limit on close" (LOC) orders. This order is eligible to execute only in the market
 * closing auction. Any unfilled orders after the close will be cancelled. CLS orders
 * submitted after 3:50pm but before 7:00pm ET will be rejected. CLS orders submitted
 * after 7:00pm will be queued and routed to the following day's closing auction. Only
 * available with API v2.
 */
 | 'cls'
/**
 * An Immediate Or Cancel (IOC) order requires all or part of the order to be executed
 * immediately. Any unfilled portion of the order is canceled. Only available with API
 * v2.
 */
 | 'ioc'
/**
 * A Fill or Kill (FOK) order is only executed if the entire order quantity can be
 * filled, otherwise the order is canceled. Only available with API v2.
 */
 | 'fok';
export declare type OrderStatus = 
/**
 * The order has been received by Alpaca, and routed to exchanges for execution. This
 * is the usual initial state of an order.
 */
'new'
/**
 * The order has been partially filled.
 */
 | 'partially_filled'
/**
 * The order has been filled, and no further updates will occur for the order.
 */
 | 'filled'
/**
 * The order is done executing for the day, and will not receive further updates until
 * the next trading day.
 */
 | 'done_for_day'
/**
 * The order has been canceled, and no further updates will occur for the order. This
 * can be either due to a cancel request by the user, or the order has been canceled by
 * the exchanges due to its time-in-force.
 */
 | 'canceled'
/**
 * The order has expired, and no further updates will occur for the order.
 */
 | 'expired'
/**
 * The order was replaced by another order, or was updated due to a market event such
 * as corporate action.
 */
 | 'replaced'
/**
 * The order is waiting to be canceled.
 */
 | 'pending_cancel'
/**
 * The order is waiting to be replaced by another order. The order will reject cancel
 * request while in this state.
 */
 | 'pending_replace'
/**
 * (Uncommon) The order has been received by Alpaca, but hasn't yet been routed to the
 * execution venue. This could be seen often out side of trading session hours.
 */
 | 'accepted'
/**
 * (Uncommon) The order has been received by Alpaca, and routed to the exchanges, but
 * has not yet been accepted for execution. This state only occurs on rare occasions.
 */
 | 'pending_new'
/**
 * (Uncommon) The order has been received by exchanges, and is evaluated for pricing.
 * This state only occurs on rare occasions.
 */
 | 'accepted_for_bidding'
/**
 * (Uncommon) The order has been stopped, and a trade is guaranteed for the order,
 * usually at a stated price or better, but has not yet occurred. This state only
 * occurs on rare occasions.
 */
 | 'stopped'
/**
 * (Uncommon) The order has been rejected, and no further updates will occur for the
 * order. This state occurs on rare occasions and may occur based on various conditions
 * decided by the exchanges.
 */
 | 'rejected'
/**
 * (Uncommon) The order has been suspended, and is not eligible for trading. This state
 * only occurs on rare occasions.
 */
 | 'suspended'
/**
 * (Uncommon) The order has been completed for the day (either filled or done for day),
 * but remaining settlement calculations are still pending. This state only occurs on
 * rare occasions.
 */
 | 'calculated';
export interface RawLatestTrade {
    symbol: string;
    trade: {
        t: string;
        x: string;
        p: number;
        s: number;
        c: string[];
        i: number;
        z: string;
    };
}
export interface LatestTrade {
    raw(): RawLatestTrade;
    symbol: string;
    trade: {
        t: Date;
        x: string;
        p: number;
        s: number;
        c: string[];
        i: number;
        z: string;
    };
}
/**
 * An Order in Alpaca
 */
export interface Order {
    /**
     * Get the raw data, exactly as it came from Alpaca
     */
    raw(): RawOrder;
    /**
     * Order id
     */
    id: string;
    /**
     * Client unique order id
     */
    client_order_id: string;
    /**
     * When the order was created
     */
    created_at: Date;
    /**
     * When the order was last updated
     */
    updated_at: Date;
    /**
     * When the order was submitted
     */
    submitted_at: Date;
    /**
     * When the order was filled
     */
    filled_at: Date;
    /**
     * When the order expired
     */
    expired_at: Date;
    /**
     * When the order was canceled
     */
    canceled_at: Date;
    /**
     * When the order failed
     */
    failed_at: Date;
    /**
     * When the order was last replaced
     */
    replaced_at: Date;
    /**
     * The order ID that this order was replaced by
     */
    replaced_by: string;
    /**
     * The order ID that this order replaces
     */
    replaces: string;
    /**
     * Asset ID
     */
    asset_id: string;
    /**
     * Asset symbol
     */
    symbol: string;
    /**
     * Asset class
     */
    asset_class: string;
    /**
     * Ordered quantity
     */
    qty: number;
    /**
     * Filled quantity
     */
    filled_qty: number;
    /**
     * Order type (market, limit, stop, stop_limit, trailing_stop)
     */
    type: OrderType;
    /**
     * Buy or sell
     */
    side: OrderSide;
    /**
     * Order Time in Force
     */
    time_in_force: OrderTimeInForce;
    /**
     * Limit price
     */
    limit_price: number;
    /**
     * Stop price
     */
    stop_price: number;
    /**
     * Filled average price
     */
    filled_avg_price: number;
    /**
     * The status of the order
     */
    status: OrderStatus;
    /**
     * If true, eligible for execution outside regular trading hours.
     */
    extended_hours: boolean;
    /**
     * When querying non-simple order_class orders in a nested style, an array of Order
     * entities associated with this order. Otherwise, null.
     */
    legs: Order[];
    /**
     * The dollar value away from the high water mark for trailing stop orders.
     */
    trail_price: number;
    /**
     * The percent value away from the high water mark for trailing stop orders.
     */
    trail_percent: number;
    /**
     * The highest (lowest) market price seen since the trailing stop order was submitted.
     */
    hwm: number;
    /**
     * Mostly used for non-simple orders such as bracket, one-triggers-other, or one-cancels-other.
     */
    order_class: OrderClass;
}
/**
 * Timeseries data for equity and profit loss information of the account
 */
export interface PortfolioHistory {
    /**
     * time of each data element, left-labeled (the beginning of time window)
     */
    timestamp: number[];
    /**
     * equity value of the account in dollar amount as of the end of each time window
     */
    equity: number[];
    /**
     * profit/loss in dollar from the base value
     */
    profit_loss: number[];
    /**
     * profit/loss in percentage from the base value
     */
    profit_loss_pct: number[];
    /**
     * basis in dollar of the profit loss calculation
     */
    base_value: number;
    /**
     * time window size of each data element
     */
    timeframe: '1Min' | '5Min' | '15Min' | '1H' | '1D';
}
/**
 * A position with unparsed fields, exactly as Alpaca provides it.
 * We encourage you to use the Position interface, which has many of these fields parsed.
 */
export interface RawPosition {
    asset_id: string;
    symbol: string;
    exchange: string;
    asset_class: string;
    avg_entry_price: string;
    qty: string;
    side: string;
    market_value: string | null;
    cost_basis: string;
    unrealized_pl: string | null;
    unrealized_plpc: string | null;
    unrealized_intraday_pl: string | null;
    unrealized_intraday_plpc: string | null;
    current_price: string | null;
    lastday_price: string | null;
    change_today: string | null;
}
export declare type PositionSide = 'long' | 'short';
/**
 * A position in Alpaca
 */
export interface Position {
    /**
     * Get the raw data, exactly as it came from Alpaca
     */
    raw(): RawPosition;
    /**
     * Asset ID
     */
    asset_id: string;
    /**
     * Symbol name of the asset
     */
    symbol: string;
    /**
     * Exchange name of the asset
     */
    exchange: string;
    /**
     * Asset class name
     */
    asset_class: string;
    /**
     * Average entry price of the position
     */
    avg_entry_price: number;
    /**
     * The number of shares
     */
    qty: number;
    /**
     * long or short
     */
    side: PositionSide;
    /**
     * Total dollar amount of the position
     */
    market_value: number | null;
    /**
     * Total cost basis in dollar
     */
    cost_basis: number;
    /**
     * Unrealized profit/loss in dollars
     */
    unrealized_pl: number | null;
    /**
     * Unrealized profit/loss percent (by a factor of 1)
     */
    unrealized_plpc: number | null;
    /**
     * Unrealized profit/loss in dollars for the day
     */
    unrealized_intraday_pl: number | null;
    /**
     * Unrealized profit/loss percent (by a factor of 1)
     */
    unrealized_intraday_plpc: number | null;
    /**
     * Current asset price per share
     */
    current_price: number | null;
    /**
     * Last day's asset price per share based on the closing value of the last trading day
     */
    lastday_price: number | null;
    /**
     * Percent change from last day price (by a factor of 1)
     */
    change_today: number | null;
}
export declare type ActivityType = 
/**
 * Order fills (both partial and full fills)
 */
'FILL'
/**
 * Cash transactions (both CSD and CSR)
 */
 | 'TRANS'
/**
 * Miscellaneous or rarely used activity types (All types except those in TRANS, DIV,
 * or FILL)
 */
 | 'MISC'
/**
 * ACATS IN/OUT (Cash)
 */
 | 'ACATC'
/**
 * ACATS IN/OUT (Securities)
 */
 | 'ACATS'
/**
 * Cash disbursement(+)
 */
 | 'CSD'
/**
 * Cash receipt(-)
 */
 | 'CSR'
/**
 * Dividends
 */
 | 'DIV'
/**
 * Dividend (capital gain long term)
 */
 | 'DIVCGL'
/**
 * Dividend (capital gain short term)
 */
 | 'DIVCGS'
/**
 * Dividend fee
 */
 | 'DIVFEE'
/**
 * Dividend adjusted (Foreign Tax Withheld)
 */
 | 'DIVFT'
/**
 * Dividend adjusted (NRA Withheld)
 */
 | 'DIVNRA'
/**
 * Dividend return of capital
 */
 | 'DIVROC'
/**
 * Dividend adjusted (Tefra Withheld)
 */
 | 'DIVTW'
/**
 * Dividend (tax exempt)
 */
 | 'DIVTXEX'
/**
 * Interest (credit/margin)
 */
 | 'INT'
/**
 * Interest adjusted (NRA Withheld)
 */
 | 'INTNRA'
/**
 * Interest adjusted (Tefra Withheld)
 */
 | 'INTTW'
/**
 * Journal entry
 */
 | 'JNL'
/**
 * Journal entry (cash)
 */
 | 'JNLC'
/**
 * Journal entry (stock)
 */
 | 'JNLS'
/**
 * Merger/Acquisition
 */
 | 'MA'
/**
 * Name change
 */
 | 'NC'
/**
 * Option assignment
 */
 | 'OPASN'
/**
 * Option expiration
 */
 | 'OPEXP'
/**
 * Option exercise
 */
 | 'OPXRC'
/**
 * Pass Thru Charge
 */
 | 'PTC'
/**
 * Pass Thru Rebate
 */
 | 'PTR'
/**
 * Reorg CA
 */
 | 'REORG'
/**
 * Symbol change
 */
 | 'SC'
/**
 * Stock spinoff
 */
 | 'SSO'
/**
 * Stock split
 */
 | 'SSP';
export interface RawTradeActivity {
    activity_type: Extract<ActivityType, 'FILL'>;
    cum_qty: string;
    id: string;
    leaves_qty: string;
    price: string;
    qty: string;
    side: string;
    symbol: string;
    transaction_time: string;
    order_id: string;
    type: string;
}
export interface RawNonTradeActivity {
    activity_type: Exclude<ActivityType, 'FILL'>;
    id: string;
    date: string;
    net_amount: string;
    symbol: string;
    qty: string;
    per_share_amount: string;
}
export declare type TradeActivityType = 'fill' | 'partial_fill';
export declare type TradeActivitySide = 'buy' | 'sell';
export interface TradeActivity {
    /**
     * Get the raw data, exactly as it came from Alpaca
     */
    raw(): RawTradeActivity;
    /**
     * FILL
     */
    activity_type: Extract<ActivityType, 'FILL'>;
    /**
     * The cumulative quantity of shares involved in the execution.
     */
    cum_qty: number;
    /**
     * An id for the activity. Always in "::" format. Can be sent as page_token in requests
     * to facilitate the paging of results.
     */
    id: string;
    /**
     * For partially_filled orders, the quantity of shares that are left to be filled.
     */
    leaves_qty: number;
    /**
     * The per-share price that the trade was executed at.
     */
    price: number;
    /**
     * The number of shares involved in the trade execution.
     */
    qty: number;
    /**
     * buy or sell
     */
    side: TradeActivitySide;
    /**
     * The symbol of the security being traded.
     */
    symbol: string;
    /**
     * The time at which the execution occurred.
     */
    transaction_time: string;
    /**
     * The id for the order that filled.
     */
    order_id: string;
    /**
     * fill or partial_fill
     */
    type: TradeActivityType;
}
export interface NonTradeActivity {
    /**
     * Get the raw data, exactly as it came from Alpaca
     */
    raw(): RawNonTradeActivity;
    /**
     * Activity type
     */
    activity_type: Exclude<ActivityType, 'FILL'>;
    /**
     * An ID for the activity, always in "::" format. Can be sent as page_token in requests
     * to facilitate the paging of results.
     */
    id: string;
    /**
     * The date on which the activity occurred or on which the transaction associated with
     * the activity settled.
     */
    date: string;
    /**
     * The net amount of money (positive or negative) associated with the activity.
     */
    net_amount: number;
    /**
     * The symbol of the security involved with the activity. Not present for all activity
     * types.
     */
    symbol: string;
    /**
     * For dividend activities, the number of shares that contributed to the payment. Not
     * present for other activity types.
     */
    qty: number;
    /**
     * For dividend activities, the average amount paid per share. Not present for other
     * activity types.
     */
    per_share_amount: number;
}
export declare type RawActivity = RawTradeActivity | RawNonTradeActivity;
export declare type Activity = TradeActivity | NonTradeActivity;
/**
 * The following type mirrors OrderStatus almost exactly,
 * but differs slightly in its wording for each event.
 * See https://alpaca.markets/docs/api-references/broker-api/events/#trade-events
 * for an updated list of these events and their detailed descriptions.
 */
export declare type TradeUpdateEvent = 'new' | 'fill' | 'partial_fill' | 'canceled' | 'expired' | 'done_for_day' | 'replaced' | 'rejected' | 'pending_new' | 'stopped' | 'pending_cancel' | 'pending_replace' | 'calculated' | 'suspended' | 'order_replace_rejected' | 'order_cancel_rejected';
export interface RawTradeUpdate {
    event: TradeUpdateEvent;
    execution_id: string;
    order: RawOrder;
    event_id?: string;
    at?: string;
    timestamp?: string;
    position_qty?: string;
    price?: string;
    qty?: string;
}
export interface TradeUpdate {
    /**
     * Get the raw data, exactly as it came from Alpaca
     */
    raw: () => RawTradeUpdate;
    /**
     * Trade update event type
     */
    event: TradeUpdateEvent;
    /**
     * Corresponding execution of an order.
     * If an order gets filled over two executions (a partial_fill for example),
     * you will receive two events with different IDs.
     */
    execution_id: string;
    /**
     * Monotonically increasing 64-bit integer.
     * Haven't yet observed this property in practice, but it is
     * on Alpaca's docs here: https://alpaca.markets/docs/api-references/broker-api/events/#trade-events,
     * including for completeness.
     */
    event_id?: number;
    /**
     * The associated order that a trade_update event comes with
     */
    order: Order;
    /**
     * The timestamp of the trade update event.
     * Alpaca docs at https://alpaca.markets/docs/api-references/broker-api/events/#trade-events
     * are confusing. They say the 'at' property will contain the timestamp of
     * the event, but currently as of 3/10/22 this is in the 'timestamp' property
     * instead. Including both for completeness.
     */
    at?: Date;
    /**
     * The timestamp of the trade update event.
     * Alpaca docs at https://alpaca.markets/docs/api-references/broker-api/events/#trade-events
     * are confusing. They say the 'at' property will contain the timestamp of
     * the event, but currently as of 3/10/22 this is in the 'timestamp' property
     * instead. Including both for completeness.
     */
    timestamp?: Date;
    /**
     * The size of your total position, after a fill or partial fill event, in shares.
     */
    position_qty?: number;
    /**
     * The average price per share at which the order was filled or partially filled
     */
    price?: number;
    /**
     * The amount of shares that were filled in a trade update of type fill or partial_fill.
     * Equivalent to the order.filled_qty property, which is preferred.
     */
    qty?: number;
}
export interface Watchlist {
    /**
     * account ID
     */
    account_id: string;
    /**
     * the content of this watchlist, in the order as registered by the client
     */
    assets: Asset[];
    /**
     * When the watchlist was created
     */
    created_at: string;
    /**
     * watchlist id
     */
    id: string;
    /**
     * user-defined watchlist name (up to 64 characters)
     */
    name: string;
    /**
     * When the watchlist was last updated
     */
    updated_at: string;
}
export interface News {
    id: number;
    headline: string;
    author: string;
    created_at: Date;
    updated_at: Date;
    summary: string;
    url: string;
    images: any[];
    symbols: string[];
    source: string;
}
export interface NewsPage {
    news: News[];
    next_page_token: string;
}
export declare type Channel = 'trades' | 'quotes' | 'bars' | 'trade_updates';
export interface Message {
    T: 'success' | 'error' | 'subscription';
    code?: number;
    msg: string;
    [key: string]: any;
}