@katanaperps/katana-perps-sdk 0.0.0-placeholder

package/dist/types/enums/request.d.ts

@@ -0,0 +1,980 @@
+/**
+ * Can be used to easily provide the {@link _types.RestRequestGetCandles.interval interval} parameter
+ * in a get candles request.
+ *
+ * @example
+ * ```typescript
+ * import { RestPublicClient } from '@katanaperps/katana-perps-sdk';
+ *
+ * const publicClient = new RestPublicClient();
+ *
+ * const candles = await publicClient.getCandles({
+ *  // always has an up-to-date enumeration of valid intervals
+ *  // handled by the server.
+ *  interval: CandleInterval.ONE_HOUR,
+ *  market: 'ETH-USD',
+ * })
+ * ```
+ *
+ * <br />
+ *
+ * ---
+ *
+ * @see client  {@link _types.RestPublicClient.getCandles RestPublicClient.getCandles}
+ * @see request {@link _types.RestRequestGetCandles RestRequestGetCandles}
+ * @see related {@link _types.KatanaPerpsCandle KatanaPerpsCandle}
+ *
+ * @category Enums - Request Parameters
+ * @category KatanaPerps - Get Candles
+ * @enum
+ */
+export declare const CandleInterval: Readonly<{
+    /**
+     * - Receives candles at an interval of 1 minute.
+     */
+    readonly ONE_MINUTE: "1m";
+    /**
+     * - Receives candles at an interval of 5 minutes.
+     */
+    readonly FIVE_MINUTES: "5m";
+    /**
+     * - Receives candles at an interval of 15 minutes.
+     */
+    readonly FIFTEEN_MINUTES: "15m";
+    /**
+     * - Receives candles at an interval of 30 minutes.
+     */
+    readonly THIRTY_MINUTES: "30m";
+    /**
+     * - Receives candles at an interval of 1 hour.
+     */
+    readonly ONE_HOUR: "1h";
+    /**
+     * - Receives candles at an interval of 6 hours.
+     */
+    readonly FOUR_HOURS: "4h";
+    /**
+     * - Receives candles at an interval of 1 day.
+     */
+    readonly ONE_DAY: "1d";
+}>;
+export type CandleInterval = (typeof CandleInterval)[keyof typeof CandleInterval];
+/**
+ * Time in force policies specify the behavior of a {@link _types.KatanaPerpsOrder limit order} upon execution.
+ *
+ * @see docs    [Katana Perps API Documentation: Time in Force Explained](https://api-docs-v1-perps.katana.network/#time-in-force)
+ * @see request {@link _types.RestRequestOrderBase.timeInForce RestRequestOrder.timeInForce}
+ *  > This enum is most useful when calling the {@link _types.RestAuthenticatedClient.createOrder RestAuthenticatedClient.createOrder}
+ *    method to provide inline completion and documentation for the `timeInForce` parameter.
+ * @see related {@link _types.KatanaPerpsOrder KatanaPerpsOrder}
+ *  > The `KatanaPerpsOrder` interface provides the shape for orders and are returned whenever an order is created or queried.
+ *
+ * @category Enums - Request Parameters
+ * @category KatanaPerps - Create Order
+ * @enum
+ */
+export declare const TimeInForce: Readonly<{
+    /**
+     * **Good Till Canceled (gtc)**
+     *
+     * - The `gtc` time in force policy keeps a limit order open until it is either filled or manually canceled by the trader.
+     * - This is the default behavior for limit orders if the {@link _types.RestRequestOrderBase.timeInForce timeInForce}
+     *   parameter is not provided.
+     *
+     * ---
+     *
+     * **Characteristics:**
+     * - **Persistence**: A `gtc` order remains active on the order book until it is executed or canceled.
+     * - **Default Option**: If you do not specify a time in force, `gtc` is assumed.
+     *
+     * ---
+     *
+     * @example
+     * ```typescript
+     * import { TimeInForce, OrderType } from '@katanaperps/katana-perps-sdk';
+     *
+     * authenticatedClient.createOrder({
+     *   type: OrderType.limit,
+     *   timeInForce: TimeInForce.gtc,
+     *   // ... other limit order parameters
+     * });
+     * ```
+     *
+     * @see docs [Katana Perps API Documentation: Time in Force Explained](https://api-docs-v1-perps.katana.network/#time-in-force)
+     */
+    readonly gtc: "gtc";
+    /**
+     * **Good Til Crossing (gtx)**
+     *
+     * - The `gtx` time in force policy ensures that a limit order will only execute if it does not immediately match with an existing order.
+     * - This policy is used to guarantee that an order will only add liquidity to the market and not take liquidity away.
+     * - Applicable to all limit orders, `gtx` is particularly useful for traders who wish to avoid paying taker fees.
+     *
+     * ---
+     *
+     * **Characteristics:**
+     * - **Post-Only**:          A `gtx` order is rejected if it would immediately match with an existing order upon submission.
+     * - **Liquidity Addition**: Ensures the order contributes liquidity, qualifying it for potential maker fee rebates.
+     *
+     * ---
+     *
+     * @example
+     * ```typescript
+     * import { TimeInForce, OrderType } from '@katanaperps/katana-perps-sdk';
+     *
+     * authenticatedClient.createOrder({
+     *   type: OrderType.limit,
+     *   timeInForce: TimeInForce.gtx,
+     *   // ... other limit order parameters
+     * });
+     * ```
+     *
+     * @see docs [Katana Perps API Documentation: Time in Force Explained](https://api-docs-v1-perps.katana.network/#time-in-force)
+     */
+    readonly gtx: "gtx";
+    /**
+     * **Immediate Or Cancel (ioc)**
+     *
+     * - An `ioc` time in force policy is used for limit orders that should be executed immediately.
+     * - Any portion of the order that cannot be filled right away is canceled, ensuring no part of the order remains on the order book.
+     * - This policy is ideal for traders who prioritize speed of execution over full order fulfillment.
+     *
+     * ---
+     *
+     * **Characteristics:**
+     * - **Immediate Execution**: An `ioc` order attempts to fill immediately upon placement.
+     * - **Partial Fulfillment**: If the full order cannot be executed, the unfilled portion is immediately canceled.
+     * - **No Resting Orders**:   `ioc` orders do not become resting orders on the book, preventing any residual market impact.
+     *
+     * ---
+     *
+     * @example
+     * ```typescript
+     * import { TimeInForce, OrderType } from '@katanaperps/katana-perps-sdk';
+     *
+     * authenticatedClient.createOrder({
+     *   type: OrderType.limit,
+     *   timeInForce: TimeInForce.ioc,
+     *   // ... other limit order parameters
+     * });
+     * ```
+     *
+     * @see docs [Katana Perps API Documentation: Time in Force Explained](https://api-docs-v1-perps.katana.network/#time-in-force)
+     */
+    readonly ioc: "ioc";
+    /**
+     * **Fill Or Kill (fok)**
+     *
+     * - The `fok` time in force policy requires that a limit order be filled in its entirety immediately upon placement or not at all.
+     * - This policy is used by traders who need a guarantee that their order will be executed as a single transaction at a known price.
+     * - `fok` orders are particularly useful for large orders that could be subject to price slippage if executed in smaller increments.
+     * - `fok` orders must specify the {@link SelfTradePrevention.cn | SelfTradePrevention.cn} (Cancel Newest)
+     *   {@link _types.RestRequestOrderBase.selfTradePrevention selfTradePrevention} policy.
+     *
+     * ---
+     *
+     * **Characteristics:**
+     * - **All-or-Nothing**: A `fok` order must be completely filled with a single transaction or it is entirely canceled.
+     * - **Price Certainty**: Ensures that the order will execute at a single price point, providing full cost transparency.
+     * - **No Partial Fills**: Eliminates the possibility of partial order execution, which can be critical for certain trading strategies.
+     *
+     * ---
+     *
+     * @example
+     * ```typescript
+     * import { TimeInForce, OrderType } from '@katanaperps/katana-perps-sdk';
+     *
+     * authenticatedClient.createOrder({
+     *   type: OrderType.limit,
+     *   timeInForce: TimeInForce.fok,
+     *   // ... other limit order parameters
+     * });
+     * ```
+     *
+     * @see docs [Katana Perps API Documentation: Time in Force Explained](https://api-docs-v1-perps.katana.network/#time-in-force)
+     * @see enum {@link SelfTradePrevention}
+     *  > `fok` time in force policy requires that the {@link _types.RestRequestOrderBase.selfTradePrevention selfTradePrevention}
+     *    parameter is set to {@link SelfTradePrevention.cn} (Cancel Newest)
+     */
+    readonly fok: "fok";
+}>;
+export type TimeInForce = (typeof TimeInForce)[keyof typeof TimeInForce];
+/**
+ * Can be used as a convenience when specifying your orders to benefit from
+ * inline documentation and auto-complete.
+ *
+ * @see docs    [API Documentation: Order Types](https://api-docs-v1-perps.katana.network/#order-types)
+ * @see request {@link _types.RestRequestOrderBase.type RestRequestOrder.type}
+ * @see related {@link _types.KatanaPerpsOrder KatanaPerpsOrder}
+ *
+ * @category Enums - Request Parameters
+ * @category KatanaPerps - Create Order
+ * @enum
+ *
+ * @example
+ * ```typescript
+ *  const order = { type: OrderType.limit, ...rest }
+ * ```
+ */
+export declare const OrderType: Readonly<{
+    /**
+     * A market order is an order to buy or sell a specified quantity of an asset at the best available current price.
+     *
+     * ---
+     *
+     * **Characteristics:**
+     * - A market order requires specifying the {@link _types.RestRequestOrderBase.quantity quantity} in base terms
+     *   to be traded
+     * - **For market `buy` orders:**
+     *   - The trade executes immediately for the specified `quantity` at the current best available sell price.
+     * - **For market `sell` orders:**
+     *   - The trade executes immediately for the specified `quantity` at the current best available buy price.
+     * - Market orders prioritize speed of execution over price and are filled using the best available prices
+     *   until the order `quantity` is met.
+     * - Since market orders are filled immediately, they always remove liquidity from the order book and are
+     *   subject to taker fees.
+     * - Market orders do not enter the order book as they do not have a price specified and are executed at
+     *   the current market rate.
+     *
+     * ---
+     *
+     * @see request {@link _types.RestRequestOrderTypeMarket RestRequestOrderTypeMarket}
+     *  > The interface that provides the necessary request parameters to create a `market` order when calling
+     *    the {@link _types.RestAuthenticatedClient.createOrder RestAuthenticatedClient.createOrder} method.
+     */
+    readonly market: "market";
+    /**
+     * A limit order is an order to buy or sell a specified quantity of an asset at a price that is equal to or
+     * more favorable than a given threshold.
+     *
+     * ---
+     *
+     * **Characteristics:**
+     * - A limit order requires specifying the {@link _types.RestRequestOrderBase.quantity quantity}
+     *   to be traded (in base terms) and the limit {@link _types.RestRequestOrderBase.price price}
+     *   (in quote terms).
+     * - **For limit `buy` orders:**
+     *   - The trade executes up to the specified `quantity`, provided the market price is at or below the provided limit `price`.
+     * - **For limit `sell` orders:**
+     *   - The trade executes up to the specified `quantity`, provided the market price is at or above the limit `price`.
+     * - Limit orders that are priced to **cross the existing spread** execute immediately and remove liquidity from the order book
+     *   - *(i.e. buy orders priced above the current lowest sell price, or sell orders priced below the current highest buy price)*
+     * - Any unfilled portion of a limit order enters the order book, adhering to the specified
+     *   {@link _types.RestRequestOrderBase.timeInForce timeInForce} constraints and the maker trade minimum requirements as detailed
+     *   in [Katana Perps API Documentation - Minimums](https://api-docs-v1-perps.katana.network/#minimums).
+     *
+     * ---
+     *
+     * @see request {@link _types.RestRequestOrderTypeLimit RestRequestOrderTypeLimit}
+     *  > The interface that provides the necessary request parameters to create a `limit` order when calling
+     *    the {@link _types.RestAuthenticatedClient.createOrder RestAuthenticatedClient.createOrder} method.
+     * @see enum    {@link _types.TimeInForce TimeInForce}
+     *  > An enum which can be used when defining the {@link _types.RestRequestOrderBase.timeInForce timeInForce}
+     *    request parameter.
+     */
+    readonly limit: "limit";
+    /**
+     * A stop-loss market order is an order to `buy` or `sell` a specified quantity of an asset when
+     * its price moves past a particular point, ensuring a higher probability of achieving a predetermined
+     * entry or exit price, limiting the traders loss or locking in a profit. Once the stop price is reached,
+     * the stop-loss order becomes a market order.
+     *
+     * ---
+     *
+     * **Characteristics:**
+     * - A `stopLossMarket` order requires specifying the following request parameters:
+     *   - {@link _types.RestRequestOrderBase.quantity quantity} to be traded (in base terms)
+     *   - the stop {@link _types.RestRequestOrderBase.triggerPrice triggerPrice} (in quote terms)
+     *   - {@link _types.RestRequestOrderBase.triggerType triggerType} (enum: {@link _types.TriggerType TriggerType})
+     *     which determines the price type for the provided `triggerPrice`.
+     * - **Activation:**
+     *   - The order is not active and will not execute until the market price reaches the
+     *     specified trigger price.
+     * - **Execution:**
+     *   - Once activated, it executes as a market order at the current best available price.
+     * - **Purpose:**
+     *   - This type of order is used to limit losses or protect profits in a position.
+     * - `stopLossMarket` orders are subject to slippage in fast-moving market conditions.
+     * - These orders do not guarantee an execution at or near the trigger price.
+     *
+     * ---
+     *
+     * @see request {@link _types.RestRequestOrderTypeStopLossMarket RestRequestOrderTypeStopLossMarket}
+     *  > The interface that provides the necessary request parameters to create a `stopLossMarket` order when calling
+     *    the {@link _types.RestAuthenticatedClient.createOrder RestAuthenticatedClient.createOrder} method, including trigger price and type.
+     * @see enum {@link _types.TriggerType TriggerType}
+     *  > An enum that should be used when providing the {@link _types.RestRequestOrderBase.triggerType triggerType} parameter
+     *    to provide inline IDE completion and documentation.
+     */
+    readonly stopLossMarket: "stopLossMarket";
+    /**
+     * A `stopLossLimit` order is an order to `buy` or `sell` a specified quantity of an asset at a specified limit price,
+     * only after the asset's price has reached a specified stop price.
+     *
+     * - When the stop price is reached, the stop-loss order becomes a limit order to buy or sell at the limit price or better.
+     *
+     * ---
+     *
+     * **Characteristics:**
+     * - A `stopLossLimit` order requires specifying the following request parameters:
+     *   - {@link _types.RestRequestOrderBase.quantity quantity} to be traded (in base terms)
+     *   - the stop {@link _types.RestRequestOrderBase.triggerPrice triggerPrice}
+     *     (in quote terms) at which the order is triggered
+     *   - and the limit {@link _types.RestRequestOrderBase.price price} at which the order
+     *     should execute.
+     *   - {@link _types.RestRequestOrderBase.triggerType triggerType} (enum: {@link _types.TriggerType TriggerType})
+     *     which determines the price type for the provided `triggerPrice`
+     * - **Activation:**
+     *   - The order is not active and will not execute until the market price reaches the specified trigger price.
+     * - **Execution:**
+     *   - Once activated, it becomes a limit order that will only execute at the specified limit price or better.
+     * - **Purpose:**
+     *   - This type of order is used to limit losses or protect profits in a position while providing control over the price at which the order fills.
+     * - Stop-loss limit orders provide precision in execution price but are not guaranteed to execute if the market does not reach the limit price.
+     * - These orders can help prevent slippage by setting a specific limit price at which the order can execute.
+     *
+     * ---
+     *
+     * @see request {@link _types.RestRequestOrderTypeStopLossLimit RestRequestOrderTypeStopLossLimit}
+     *  > The interface that provides the necessary request parameters to create a `stopLossLimit` order when calling
+     *    the {@link _types.RestAuthenticatedClient.createOrder RestAuthenticatedClient.createOrder} method, including trigger price, type, and limit price.
+     * @see enum {@link _types.TriggerType TriggerType}
+     *  > An enum that should be used when providing the {@link _types.RestRequestOrderBase.triggerType triggerType} parameter
+     *    to provide inline IDE completion and documentation.
+     */
+    readonly stopLossLimit: "stopLossLimit";
+    /**
+     * A `takeProfitMarket` order is an order to sell or buy a specified quantity of an asset when its price reaches a specified
+     * profit target, ensuring a profit can be realized. Once the take-profit price is reached, the take-profit order becomes a market order.
+     *
+     * ---
+     *
+     * **Characteristics:**
+     * - A `takeProfitMarket` order requires specifying the following request parameters:
+     *   - {@link _types.RestRequestOrderBase.quantity quantity} to be traded (in base terms)
+     *   - the take-profit {@link _types.RestRequestOrderBase.triggerPrice triggerPrice}
+     *     (in quote terms) at which the order is triggered.
+     *   - {@link _types.RestRequestOrderBase.triggerType triggerType} (enum: {@link _types.TriggerType TriggerType})
+     *     which determines the price type for the provided `triggerPrice`
+     * - **Activation:**
+     *   - The order is not active and will not execute until the market price reaches the specified trigger price.
+     * - **Execution:**
+     *   - Once activated, it executes as a market order at the current best available price.
+     * - **Purpose:**
+     *   - This type of order is used to lock in profits when the asset's price reaches a level that satisfies the trader's profit target.
+     * - `takeProfitMarket` orders are subject to slippage in fast-moving market conditions.
+     * - These orders do not guarantee an execution at or near the trigger price.
+     *
+     * ---
+     *
+     * @see request {@link _types.RestRequestOrderTypeTakeProfitMarket RestRequestOrderTypeTakeProfitMarket}
+     *  > The interface that provides the necessary request parameters to create a `takeProfitMarket` order when calling
+     *    the {@link _types.RestAuthenticatedClient.createOrder RestAuthenticatedClient.createOrder} method, including trigger price and type.
+     * @see enum {@link _types.TriggerType TriggerType}
+     *  > An enum that should be used when providing the {@link _types.RestRequestOrderBase.triggerType triggerType} parameter
+     *    to provide inline IDE completion and documentation.
+     */
+    readonly takeProfitMarket: "takeProfitMarket";
+    /**
+     * A take-profit limit order is an order to sell or buy a specified quantity of an asset at a specified limit price,
+     * only after the asset's price has reached a specified profit target. When the take-profit price is reached, the take-profit order
+     * becomes a limit order to sell or buy at the limit price or better.
+     *
+     * ---
+     *
+     * **Characteristics:**
+     * - A take-profit limit order requires specifying the {@link _types.RestRequestOrderBase.quantity quantity}
+     *   to be traded (in base terms), the take-profit {@link _types.RestRequestOrderBase.triggerPrice triggerPrice}
+     *   (in quote terms) at which the order is triggered, and the limit {@link _types.RestRequestOrderBase.price price}
+     *   at which the order should execute.
+     * - Additionally, the {@link _types.RestRequestOrderBase.triggerType triggerType} must be specified,
+     *   indicating the price type for the trigger price (e.g., "last" or "index").
+     * - **Activation:**
+     *   - The order is not active and will not execute until the market price reaches the specified trigger price.
+     * - **Execution:**
+     *   - Once activated, it becomes a limit order that will only execute at the specified limit price or better.
+     * - **Purpose:**
+     *   - This type of order is used to lock in profits when the asset's price reaches a level that satisfies the trader's profit target,
+     *     while providing control over the price at which the order fills.
+     * - Take-profit limit orders provide precision in execution price but are not guaranteed to execute if the market does not reach the limit price.
+     * - These orders can help prevent slippage by setting a specific limit price at which the order can execute.
+     *
+     * ---
+     *
+     * @see request {@link _types.RestRequestOrderTypeTakeProfitLimit RestRequestOrderTypeTakeProfitLimit}
+     *  > The interface that provides the necessary request parameters to create a `takeProfitLimit` order when calling
+     *    the {@link _types.RestAuthenticatedClient.createOrder RestAuthenticatedClient.createOrder} method, including trigger price, type, and limit price.
+     * @see enum {@link _types.TriggerType TriggerType}
+     *  > An enum that should be used when providing the {@link _types.RestRequestOrderBase.triggerType triggerType} parameter
+     *    to provide inline IDE completion and documentation.
+     */
+    readonly takeProfitLimit: "takeProfitLimit";
+    /**
+     * A `trailingStopMarket` order is an order that allows you to sell or buy at the market price once your asset has moved
+     * unfavorably by a specified distance (the trailing amount) from its peak price achieved after order placement.
+     *
+     * - It's designed to protect gains by enabling a trade to remain open and continue to profit as long as the price is moving
+     *   in the favorable direction, but closes the trade if the price changes direction by a specified trailing amount.
+     *
+     * ---
+     *
+     * **Characteristics:**
+     * - A `trailingStopMarket` order requires specifying the following request parameters:
+     *   - {@link _types.RestRequestOrderBase.quantity quantity} to be traded (in base terms)
+     *   - the activation {@link _types.RestRequestOrderBase.triggerPrice triggerPrice}
+     *     (in quote terms) at which the order is triggered.
+     *   - {@link _types.RestRequestOrderBase.triggerType triggerType} (enum: {@link _types.TriggerType TriggerType})
+     *     which determines the price type for the provided `triggerPrice`
+     *   - (Coming Soon: `callbackRate`%, `conditionalOrderId` for added flexibility options)
+     * - **Activation:**
+     *   - The order is active immediately upon placement, but the trigger price is dynamic and trails
+     *     the peak price by the specified trailing amount.
+     * - **Execution:**
+     *   - If the asset's price moves unfavorably by the trailing amount from its peak price, the order
+     *     becomes a market order and executes at the current best available price.
+     * - **Purpose:**
+     *   - This type of order is used to secure profits while maintaining a position that could potentially
+     *     benefit from further price movement.
+     * - `trailingStopMarket` orders are subject to slippage in fast-moving market conditions.
+     * - These orders do not guarantee an execution at or near the trigger price once activated.
+     *
+     * ---
+     *
+     * @see request {@link _types.RestRequestOrderTypeTrailingStopMarket RestRequestOrderTypeTrailingStopMarket}
+     *  > The interface that provides the necessary request parameters to create a `trailingStopMarket` order when calling
+     *    the {@link _types.RestAuthenticatedClient.createOrder RestAuthenticatedClient.createOrder} method, including trailing amount and trigger type.
+     * @see enum {@link _types.TriggerType TriggerType}
+     *  > An enum that should be used when providing the {@link _types.RestRequestOrderBase.triggerType triggerType} parameter
+     *    to provide inline IDE completion and documentation.
+     */
+    readonly trailingStopMarket: "trailingStopMarket";
+}>;
+export type OrderType = (typeof OrderType)[keyof typeof OrderType];
+/**
+ * @internal
+ */
+export declare const OrderSubType: Readonly<{
+    conditional: "conditional";
+}>;
+/**
+ * @internal
+ */
+export type OrderSubType = (typeof OrderSubType)[keyof typeof OrderSubType];
+/**
+ * @see request {@link _types.RestRequestOrderBase.side RestRequestOrder.side}
+ * @see related {@link _types.KatanaPerpsOrder KatanaPerpsOrder Interface}
+ * @see related {@link _types.KatanaPerpsFill KatanaPerpsFill Interface}
+ *
+ * @category Enums - Request Parameters
+ * @category KatanaPerps - Create Order
+ * @enum
+ */
+export declare const OrderSide: Readonly<{
+    readonly buy: "buy";
+    readonly sell: "sell";
+}>;
+export type OrderSide = (typeof OrderSide)[keyof typeof OrderSide];
+/**
+ * Provides all available self-trade prevention policies in a way that provides inline documentation,
+ * auto-completion, and linking for easy type/code navigation.
+ *
+ * @see docs    [API Documentation: Self-Trade Prevention](https://api-docs-v1-perps.katana.network/#self-trade-prevention)
+ * @see request {@link _types.RestRequestOrderBase.selfTradePrevention RestRequestOrder.selfTradePrevention}
+ * @see related {@link _types.KatanaPerpsOrder KatanaPerpsOrder}
+ *
+ * @category Enums - Request Parameters
+ * @category KatanaPerps - Create Order
+ * @enum
+ */
+export declare const SelfTradePrevention: Readonly<{
+    /**
+     * ### Decrement And Cancel (dc)
+     *
+     * - When two orders from the same user cross, the smaller order will
+     *   be canceled and the larger order size will be decremented by the smaller order size.
+     * - If the two orders are the same size, both will be canceled.
+     */
+    readonly dc: "dc";
+    /**
+     * ### Cancel Oldest (co)
+     *
+     * - Cancel the older (maker) order in full
+     */
+    readonly co: "co";
+    /**
+     * ### Cancel Newest (cn)
+     *
+     * - Cancel the newer, taker order and leave the older, resting order on the
+     *   order book.
+     * - This is the only valid option when {@link TimeInForce timeInForce} is set to {@link TimeInForce.fok TimeInForce.fok (Fill Or Kill)}
+     */
+    readonly cn: "cn";
+    /**
+     * ### Cancel Both (cb)
+     *
+     * - Cancel both orders
+     */
+    readonly cb: "cb";
+}>;
+export type SelfTradePrevention = (typeof SelfTradePrevention)[keyof typeof SelfTradePrevention];
+/**
+ * The available payout programs to use for the payout program endpoints.
+ *
+ * @category Enums - Request Parameters
+ * @category KatanaPerps - Get Payouts
+ * @category KatanaPerps - Authorize Payout
+ * @enum
+ */
+export declare const PayoutProgram: Readonly<{
+    /**
+     * The rewards programs for points.
+     */
+    readonly pointsRewards: "pointsRewards";
+    /**
+     * The rewards program for qualified Market Makers.
+     */
+    readonly marketMakerRewards: "marketMakerRewards";
+    /**
+     * The rewards program for referrals.
+     */
+    readonly referralRewards: "referralRewards";
+    /**
+     * The synthetic farms program
+     */
+    readonly syntheticFarms: "syntheticFarms";
+    /**
+     * The trading competition program.
+     */
+    readonly tradingCompetitions: "tradingCompetitions";
+    /**
+     * The Katana Perps Trading Rewards program.
+     */
+    readonly tradingRewardsV2: "tradingRewardsV2";
+}>;
+export type PayoutProgram = (typeof PayoutProgram)[keyof typeof PayoutProgram];
+/**
+ * Supported Bridge Targets
+ *
+ * @enum
+ */
+export declare const BridgeTarget: {
+    readonly KATANA_KATANA: "katana.katana";
+    readonly LAYERZERO_BERACHAIN: "stargate.berachain";
+    readonly STARGATE_ARBITRUM: "stargate.arbitrum";
+    readonly STARGATE_AURORA: "stargate.aurora";
+    readonly STARGATE_AVALANCHE: "stargate.avalanche";
+    readonly STARGATE_BASE: "stargate.base";
+    readonly STARGATE_BNB: "stargate.bnb";
+    readonly STARGATE_ETHEREUM: "stargate.ethereum";
+    readonly STARGATE_OPTIMISM: "stargate.optimism";
+    readonly STARGATE_RARI: "stargate.rari";
+    readonly STARGATE_SCROLL: "stargate.scroll";
+    readonly STARGATE_TAIKO: "stargate.taiko";
+};
+export type BridgeTarget = (typeof BridgeTarget)[keyof typeof BridgeTarget];
+/**
+ * @internal
+ *
+ * All possible values for deposit bridgeSource.
+ *
+ * @enum
+ */
+export declare const DepositSource: {
+    readonly KATANA_REFERRAL_REWARD: "katana.referralReward";
+    readonly KATANA_WALLET_BANKROLL: "katana.walletBankroll";
+    readonly KATANA_KATANA: "katana.katana";
+    readonly LAYERZERO_BERACHAIN: "stargate.berachain";
+    readonly STARGATE_ARBITRUM: "stargate.arbitrum";
+    readonly STARGATE_AURORA: "stargate.aurora";
+    readonly STARGATE_AVALANCHE: "stargate.avalanche";
+    readonly STARGATE_BASE: "stargate.base";
+    readonly STARGATE_BNB: "stargate.bnb";
+    readonly STARGATE_ETHEREUM: "stargate.ethereum";
+    readonly STARGATE_OPTIMISM: "stargate.optimism";
+    readonly STARGATE_RARI: "stargate.rari";
+    readonly STARGATE_SCROLL: "stargate.scroll";
+    readonly STARGATE_TAIKO: "stargate.taiko";
+};
+export type DepositSource = (typeof DepositSource)[keyof typeof DepositSource];
+/**
+ * An enumeration providing all possible events that the {@link OrderBookRealTimeClient} can emit.
+ *
+ * @enum
+ *
+ * @category Enums - Request Parameters
+ */
+export declare const OrderBookRealTimeClientEvent: {
+    /**
+     * Emitted when the client is ready to receive messages.
+     */
+    readonly ready: "ready";
+    /**
+     * Emitted when the client connects to the WebSocket server.
+     */
+    readonly connected: "connected";
+    /**
+     * Emitted when the client disconnects from the WebSocket server.
+     */
+    readonly disconnected: "disconnected";
+    /**
+     * Emitted when the client receives an error from the WebSocket server.
+     *
+     * - Includes an {@link Error} argument with more details about the error
+     *   that occurred.
+     */
+    readonly error: "error";
+    /**
+     * Emitted when the orderbook requires a sync from the REST API due to
+     * thrashing or an unexpected sequence number.
+     */
+    readonly sync: "sync";
+    /**
+     * Emitted when the client receives a message from the WebSocket server.
+     *
+     * - Includes the market string as an argument made to the handler
+     *   so that the appropriate request can be made to
+     *   {@link OrderBookRealTimeClient.getOrderBookL1}
+     */
+    readonly l1: "l1";
+    /**
+     * Emitted when the client receives a message from the WebSocket server.
+     *
+     * - Includes the market string as an argument made to the handler
+     *   so that the appropriate request can be made to
+     *   {@link OrderBookRealTimeClient.getOrderBookL2}
+     */
+    readonly l2: "l2";
+};
+export type OrderBookRealTimeClientEvent = (typeof OrderBookRealTimeClientEvent)[keyof typeof OrderBookRealTimeClientEvent];
+/**
+ * All possible WebSocket Subscription Names that require authenticated
+ * WebSocket connections.
+ *
+ * @example
+ * ```typescript
+ *  import {
+ *    WebSocketClient,
+ *    SubscriptionNameAuthenticated
+ *  } from '@katanaperps/katana-perps-sdk';
+ *
+ *  const client = new WebSocketClient({
+ *    auth: {
+ *      apiKey: '...',
+ *      apiSecret: '...',
+ *      wallet: '0x...'
+ *    }
+ *  })
+ *
+ *  client.onMessage(message => {
+ *    console.log('Received WebSocket Message: ', message)
+ *  })
+ *
+ *  await client.subscribeAuthenticated([
+ *    { name: SubscriptionNameAuthenticated.positions },
+ *    { name: SubscriptionNameAuthenticated.orders },
+ *  ])
+ * ```
+ *
+ * <br />
+ *
+ * ---
+ *
+ * @see request {@link _types.WebSocketClient.subscribeAuthenticated WebSocketClient.subscribeAuthenticated}
+ * @see related {@link SubscriptionNamePublic}
+ *
+ * @category Enums - Request Parameters
+ * @category WebSocket - Subscribe
+ * @enum
+ */
+export declare const SubscriptionNameAuthenticated: {
+    /**
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsDepositEvent KatanaPerpsDepositEvent} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsDepositEventData KatanaPerpsDepositEventData}
+     */
+    readonly deposits: "deposits";
+    /**
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsFundingPaymentEvent KatanaPerpsFundingPaymentEvent} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsFundingPaymentEventData KatanaPerpsFundingPaymentEventData}
+     */
+    readonly fundingPayments: "fundingPayments";
+    /**
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsOrderEvent KatanaPerpsOrderEvent} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsOrderEventData KatanaPerpsOrderEventData}
+     */
+    readonly orders: "orders";
+    /**
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsPositionEvent KatanaPerpsPositionEvent} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsPositionEventData KatanaPerpsPositionEventData}
+     */
+    readonly positions: "positions";
+    /**
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsWithdrawalEvent KatanaPerpsWithdrawalEvent} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsWithdrawalEventData KatanaPerpsWithdrawalEventData}
+     */
+    readonly withdrawals: "withdrawals";
+    /**
+     * @internal
+     */
+    readonly webclient: "webclient";
+};
+export type SubscriptionNameAuthenticated = (typeof SubscriptionNameAuthenticated)[keyof typeof SubscriptionNameAuthenticated];
+/**
+ * All possible WebSocket Subscription Names that require authenticated
+ * WebSocket connections.
+ *
+ * @example
+ * ```typescript
+ *  import {
+ *    WebSocketClient,
+ *    SubscriptionNamePublic,
+ *    CandleInterval
+ *  } from '@katanaperps/katana-perps-sdk';
+ *
+ *  const client = new WebSocketClient();
+ *
+ *  client.onMessage(message => {
+ *    console.log('Received WebSocket Message: ', message)
+ *  })
+ *
+ *  await client.subscribePublic([
+ *    // will inherit markets from the markets array
+ *    { name: SubscriptionNamePublic.tickers },
+ *  ], ['ETH-USD'])
+ * ```
+ *
+ * <br />
+ *
+ * ---
+ *
+ * @see request {@link _types.WebSocketClient.subscribePublic WebSocketClient.subscribePublic}
+ * @see related {@link SubscriptionNameAuthenticated}
+ *
+ * @category Enums - Request Parameters
+ * @category WebSocket - Subscribe
+ * @enum
+ */
+export declare const SubscriptionNamePublic: Readonly<{
+    /**
+     * **Subscribe Requirements:**
+     *
+     * - Requires a `markets` array to subscribe to.
+     *
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsTickerEvent KatanaPerpsTickerEvent} WebSocket updates via the
+     *   {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsTickerEventData KatanaPerpsTickerEventData}
+     */
+    readonly tickers: "tickers";
+    /**
+     * **Subscribe Requirements:**
+     *
+     * - Requires a `markets` array to subscribe to.
+     *
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsTradeEvent KatanaPerpsTradeEvent} WebSocket updates via the
+     *   {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsTradeEventData KatanaPerpsTradeEventData}
+     */
+    readonly trades: "trades";
+    /**
+     * **Subscribe Requirements:**
+     *
+     * - Requires a `markets` array to subscribe to.
+     *
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsLiquidationEvent KatanaPerpsLiquidationEvent} WebSocket updates via the
+     *   {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsLiquidationEventData KatanaPerpsLiquidationEventData}
+     */
+    readonly liquidations: "liquidations";
+    /**
+     * **Subscribe Requirements:**
+     *
+     * - Requires a `markets` array to subscribe to.
+     * - Requires a {@link _types.CandleInterval CandleInterval} property
+     *
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsCandleEvent KatanaPerpsCandleEvent} WebSocket updates via the
+     *   {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsCandleEventData KatanaPerpsCandleEventData}
+     */
+    readonly candles: "candles";
+    /**
+     * **Subscribe Requirements:**
+     *
+     * - Requires a `markets` array to subscribe to.
+     *
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsOrderBookLevel1Event KatanaPerpsOrderBookLevel1Event} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsOrderBookLevel1EventData KatanaPerpsOrderBookLevel1EventData}
+     */
+    readonly l1orderbook: "l1orderbook";
+    /**
+     * **Subscribe Requirements:**
+     *
+     * - Requires a `markets` array to subscribe to.
+     *
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsOrderBookLevel2Event KatanaPerpsOrderBookLevel2Event} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsOrderBookLevel2EventData KatanaPerpsOrderBookLevel2EventData}
+     */
+    readonly l2orderbook: "l2orderbook";
+    /**
+     * @internal
+     */
+    readonly webclient: "webclient";
+}>;
+export type SubscriptionNamePublic = (typeof SubscriptionNamePublic)[keyof typeof SubscriptionNamePublic];
+/**
+ * A combination of {@link SubscriptionNameAuthenticated} and {@link SubscriptionNamePublic}
+ * provided as a convenience.
+ *
+ * - Generally using the separated enums is useful as it makes it obvious which subscriptions
+ *   are accepted by the {@link _types.WebSocketClient.subscribeAuthenticated WebSocketClient.subscribeAuthenticated}
+ *   and {@link _types.WebSocketClient.subscribePublic WebSocketClient.subscribePublic} methods.
+ *
+ * @see related {@link SubscriptionNameAuthenticated}
+ * @see related {@link SubscriptionNamePublic}
+ *
+ * @category Enums - Request Parameters
+ * @category WebSocket - Subscribe
+ * @enum
+ */
+export declare const SubscriptionName: {
+    /**
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsDepositEvent KatanaPerpsDepositEvent} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsDepositEventData KatanaPerpsDepositEventData}
+     */
+    readonly deposits: "deposits";
+    /**
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsFundingPaymentEvent KatanaPerpsFundingPaymentEvent} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsFundingPaymentEventData KatanaPerpsFundingPaymentEventData}
+     */
+    readonly fundingPayments: "fundingPayments";
+    /**
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsOrderEvent KatanaPerpsOrderEvent} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsOrderEventData KatanaPerpsOrderEventData}
+     */
+    readonly orders: "orders";
+    /**
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsPositionEvent KatanaPerpsPositionEvent} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsPositionEventData KatanaPerpsPositionEventData}
+     */
+    readonly positions: "positions";
+    /**
+     * **Subscription Update Events:**
+     *
+     * - Receives {@link _types.KatanaPerpsWithdrawalEvent KatanaPerpsWithdrawalEvent} WebSocket updates via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     * - `event.data` will match {@link _types.KatanaPerpsWithdrawalEventData KatanaPerpsWithdrawalEventData}
+     */
+    readonly withdrawals: "withdrawals";
+    /**
+     * @internal
+     */
+    readonly webclient: "webclient";
+    readonly tickers: "tickers";
+    readonly trades: "trades";
+    readonly liquidations: "liquidations";
+    readonly candles: "candles";
+    readonly l1orderbook: "l1orderbook";
+    readonly l2orderbook: "l2orderbook";
+};
+export type SubscriptionName = (typeof SubscriptionName)[keyof typeof SubscriptionName];
+/**
+ * @internal
+ *
+ * Available WebSocket Request Methods
+ *
+ * @enum
+ */
+export declare const WebSocketRequestMethod: Readonly<{
+    /**
+     * Creates a new subscription or subscriptions
+     *
+     * **Subscription Update Events:**
+     *
+     * - Receives a {@link _types.KatanaPerpsSubscriptionsListEvent KatanaPerpsSubscriptionsListEvent} WebSocket response via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler listing all active
+     *   subscriptions.
+     * - Begins receiving {@link _types.KatanaPerpsSubscriptionEvent KatanaPerpsSubscriptionEvent}'s for all subscribed
+     *   subscriptions via the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler.
+     */
+    readonly subscribe: "subscribe";
+    /**
+     * Unsubscribes from a subscription or subscriptions
+     *
+     * **Subscription Update Events:**
+     *
+     * - Receives a {@link _types.KatanaPerpsSubscriptionsListEvent KatanaPerpsSubscriptionsListEvent} WebSocket response via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler listing all active
+     *   subscriptions..
+     */
+    readonly unsubscribe: "unsubscribe";
+    /**
+     * List all active subscriptions
+     *
+     * **Subscription Update Events:**
+     *
+     * - Receives a {@link _types.KatanaPerpsSubscriptionsListEvent KatanaPerpsSubscriptionsListEvent} WebSocket response via
+     *   the {@link _types.WebSocketClient.onMessage WebSocketClient.onMessage} handler listing all active
+     *   subscriptions.
+     */
+    readonly subscriptions: "subscriptions";
+    /**
+     * Ping the server to check if the connection is still alive
+     * and to maintain the connection (indicate we are still active).
+     *
+     * A `pong` is dispatched automatically from the server.
+     */
+    readonly ping: "ping";
+    /**
+     * @internal
+     *
+     * **WARNING:***
+     *
+     * This uses a propietary internal mechanism that is automatically handled by
+     * most WebSocket libraries.
+     *
+     * It is here for internal use and attempting to make a request of this value
+     * will result in a runtime error.
+     */
+    readonly pong: "pong";
+}>;
+export type WebSocketRequestMethod = (typeof WebSocketRequestMethod)[keyof typeof WebSocketRequestMethod];
+//# sourceMappingURL=request.d.ts.map