@polyester/sdk 0.0.0

package/dist/services/triggers/triggers-output.schemas.d.ts

@@ -0,0 +1,688 @@
+import { FeeAsset, SelfTradePreventionMode, Side, TriggerDirection, TriggerPriceSource } from "../../gen/orders/v1/orders_pb.js";
+import { LadderDistribution, TriggerEventType, TriggerStatus, TriggerType } from "../../gen/triggers/v1/triggers_pb.js";
+import { SdkScales } from "../../shared/decimal-surface.js";
+import * as v from "valibot";
+//#region src/services/triggers/triggers-output.schemas.d.ts
+type TriggerPriceSourceLabel = "last" | "index" | "mark" | "unspecified";
+type TriggerDirectionLabel = "above" | "below" | "unspecified";
+type LadderDistributionLabel = "linear" | "geometric" | "weighted_favorable" | "unspecified";
+declare const CreateTriggerResultSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly triggerId: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+  readonly clientTriggerId: v.StringSchema<undefined>;
+  readonly acceptedAt: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ObjectSchema<{
+    readonly seconds: v.BigintSchema<undefined>;
+    readonly nanos: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
+  }, undefined>, undefined>, v.TransformAction<{
+    seconds: bigint;
+    nanos: number;
+  } | undefined, number | undefined>]>;
+  readonly acceptedAtTsNs: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+}, undefined>, v.TransformAction<{
+  triggerId: string;
+  clientTriggerId: string;
+  acceptedAt?: number | undefined;
+  acceptedAtTsNs: string;
+}, {
+  acceptedAt: number;
+  acceptedAtNs: string;
+  triggerId: string;
+  clientTriggerId: string;
+}>]>;
+type CreateTriggerResult = v.InferOutput<typeof CreateTriggerResultSchema>;
+declare const CancelTriggerResultSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly triggerId: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+  readonly status: v.SchemaWithPipe<readonly [v.EnumSchema<typeof TriggerStatus, undefined>, v.TransformAction<TriggerStatus, "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused">]>;
+  readonly tsNs: v.BigintSchema<undefined>;
+}, undefined>, v.TransformAction<{
+  triggerId: string;
+  status: "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused";
+  tsNs: bigint;
+}, {
+  ts: number;
+  tsNs: string;
+  triggerId: string;
+  status: "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused";
+}>]>;
+type CancelTriggerResult = v.InferOutput<typeof CancelTriggerResultSchema>;
+declare const ModifyTriggerResultSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly triggerId: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+  readonly status: v.SchemaWithPipe<readonly [v.EnumSchema<typeof TriggerStatus, undefined>, v.TransformAction<TriggerStatus, "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused">]>;
+  readonly tsNs: v.BigintSchema<undefined>;
+}, undefined>, v.TransformAction<{
+  triggerId: string;
+  status: "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused";
+  tsNs: bigint;
+}, {
+  ts: number;
+  tsNs: string;
+  triggerId: string;
+  status: "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused";
+}>]>;
+type ModifyTriggerResult = v.InferOutput<typeof ModifyTriggerResultSchema>;
+declare const PauseTriggerResultSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly triggerId: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+  readonly status: v.SchemaWithPipe<readonly [v.EnumSchema<typeof TriggerStatus, undefined>, v.TransformAction<TriggerStatus, "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused">]>;
+  readonly tsNs: v.BigintSchema<undefined>;
+}, undefined>, v.TransformAction<{
+  triggerId: string;
+  status: "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused";
+  tsNs: bigint;
+}, {
+  ts: number;
+  tsNs: string;
+  triggerId: string;
+  status: "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused";
+}>]>;
+type PauseTriggerResult = v.InferOutput<typeof PauseTriggerResultSchema>;
+declare const ResumeTriggerResultSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly triggerId: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+  readonly status: v.SchemaWithPipe<readonly [v.EnumSchema<typeof TriggerStatus, undefined>, v.TransformAction<TriggerStatus, "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused">]>;
+  readonly tsNs: v.BigintSchema<undefined>;
+}, undefined>, v.TransformAction<{
+  triggerId: string;
+  status: "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused";
+  tsNs: bigint;
+}, {
+  ts: number;
+  tsNs: string;
+  triggerId: string;
+  status: "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused";
+}>]>;
+type ResumeTriggerResult = v.InferOutput<typeof ResumeTriggerResultSchema>;
+type StopDetailsOutput = {
+  case: "stop";
+  triggerPrice: string;
+  triggerPriceSource: TriggerPriceSourceLabel;
+  triggerDirection: TriggerDirectionLabel;
+};
+type TrailingDetailsOutput = {
+  case: "trailing";
+  trailingDistance: string | undefined;
+  trailingDistanceBps: number;
+  activationPrice: string | undefined;
+  peakPrice: string | undefined;
+  troughPrice: string | undefined;
+  maxSlippage: string | undefined;
+  maxSlippageBps: number;
+  triggerPriceSource: TriggerPriceSourceLabel;
+  triggerDirection: TriggerDirectionLabel;
+};
+type TwapDetailsOutput = {
+  case: "twap";
+  twapDurationMs: number;
+  twapSliceIntervalMs: number;
+  sliceIdx: number;
+  sliceCount: number;
+  /** Cumulative filled child-order base quantity. */
+  executedQty: string;
+};
+type LadderDetailsOutput = {
+  case: "ladder";
+  ladderPriceMin: string;
+  ladderPriceMax: string;
+  ladderLevels: number;
+  ladderDistribution: LadderDistributionLabel;
+};
+type TriggerDetailsOutput = StopDetailsOutput | TrailingDetailsOutput | TwapDetailsOutput | LadderDetailsOutput | {
+  case: undefined;
+};
+declare function createTriggerSchema(scales: SdkScales): v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly triggerId: v.BigintSchema<undefined>;
+  readonly subaccountId: v.BigintSchema<undefined>;
+  readonly symbolId: v.NumberSchema<undefined>;
+  readonly symbol: v.StringSchema<undefined>;
+  readonly status: v.EnumSchema<typeof TriggerStatus, undefined>;
+  readonly parentOrderId: v.OptionalSchema<v.BigintSchema<undefined>, undefined>;
+  readonly qtyScaled: v.BigintSchema<undefined>;
+  readonly feeAsset: v.EnumSchema<typeof FeeAsset, undefined>;
+  readonly selfTradePreventionMode: v.EnumSchema<typeof SelfTradePreventionMode, undefined>;
+  readonly configuration: v.VariantSchema<"case", [v.ObjectSchema<{
+    readonly case: v.LiteralSchema<"stopLoss", undefined>;
+    readonly value: v.ObjectSchema<{
+      readonly triggerPriceTicks: v.BigintSchema<undefined>;
+      readonly side: v.EnumSchema<typeof Side, undefined>;
+      readonly child: v.OptionalSchema<v.ObjectSchema<{
+        readonly execution: v.VariantSchema<"case", [v.ObjectSchema<{
+          readonly case: v.LiteralSchema<"marketIoc", undefined>;
+          readonly value: v.ObjectSchema<{}, undefined>;
+        }, undefined>, v.ObjectSchema<{
+          readonly case: v.LiteralSchema<"limitGtc", undefined>;
+          readonly value: v.ObjectSchema<{
+            readonly priceTicks: v.BigintSchema<undefined>;
+            readonly postOnly: v.BooleanSchema<undefined>;
+          }, undefined>;
+        }, undefined>, v.ObjectSchema<{
+          readonly case: v.LiteralSchema<"limitIoc", undefined>;
+          readonly value: v.ObjectSchema<{
+            readonly priceTicks: v.BigintSchema<undefined>;
+          }, undefined>;
+        }, undefined>, v.ObjectSchema<{
+          readonly case: v.LiteralSchema<"limitFok", undefined>;
+          readonly value: v.ObjectSchema<{
+            readonly priceTicks: v.BigintSchema<undefined>;
+          }, undefined>;
+        }, undefined>, v.ObjectSchema<{
+          readonly case: v.UndefinedSchema<undefined>;
+          readonly value: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+        }, undefined>], undefined>;
+      }, undefined>, undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly case: v.LiteralSchema<"takeProfit", undefined>;
+    readonly value: v.ObjectSchema<{
+      readonly triggerPriceTicks: v.BigintSchema<undefined>;
+      readonly side: v.EnumSchema<typeof Side, undefined>;
+      readonly child: v.OptionalSchema<v.ObjectSchema<{
+        readonly execution: v.VariantSchema<"case", [v.ObjectSchema<{
+          readonly case: v.LiteralSchema<"marketIoc", undefined>;
+          readonly value: v.ObjectSchema<{}, undefined>;
+        }, undefined>, v.ObjectSchema<{
+          readonly case: v.LiteralSchema<"limitGtc", undefined>;
+          readonly value: v.ObjectSchema<{
+            readonly priceTicks: v.BigintSchema<undefined>;
+            readonly postOnly: v.BooleanSchema<undefined>;
+          }, undefined>;
+        }, undefined>, v.ObjectSchema<{
+          readonly case: v.LiteralSchema<"limitIoc", undefined>;
+          readonly value: v.ObjectSchema<{
+            readonly priceTicks: v.BigintSchema<undefined>;
+          }, undefined>;
+        }, undefined>, v.ObjectSchema<{
+          readonly case: v.LiteralSchema<"limitFok", undefined>;
+          readonly value: v.ObjectSchema<{
+            readonly priceTicks: v.BigintSchema<undefined>;
+          }, undefined>;
+        }, undefined>, v.ObjectSchema<{
+          readonly case: v.UndefinedSchema<undefined>;
+          readonly value: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+        }, undefined>], undefined>;
+      }, undefined>, undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly case: v.LiteralSchema<"trailingStop", undefined>;
+    readonly value: v.ObjectSchema<{
+      readonly trailingDistance: v.VariantSchema<"case", [v.ObjectSchema<{
+        readonly case: v.LiteralSchema<"trailingDistanceTicks", undefined>;
+        readonly value: v.BigintSchema<undefined>;
+      }, undefined>, v.ObjectSchema<{
+        readonly case: v.LiteralSchema<"trailingDistanceBps", undefined>;
+        readonly value: v.NumberSchema<undefined>;
+      }, undefined>, v.ObjectSchema<{
+        readonly case: v.UndefinedSchema<undefined>;
+        readonly value: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+      }, undefined>], undefined>;
+      readonly activationPriceTicks: v.BigintSchema<undefined>;
+      readonly maxSlippage: v.VariantSchema<"case", [v.ObjectSchema<{
+        readonly case: v.LiteralSchema<"maxSlippageTicks", undefined>;
+        readonly value: v.NumberSchema<undefined>;
+      }, undefined>, v.ObjectSchema<{
+        readonly case: v.LiteralSchema<"maxSlippageBps", undefined>;
+        readonly value: v.NumberSchema<undefined>;
+      }, undefined>, v.ObjectSchema<{
+        readonly case: v.UndefinedSchema<undefined>;
+        readonly value: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+      }, undefined>], undefined>;
+      readonly side: v.EnumSchema<typeof Side, undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly case: v.LiteralSchema<"twap", undefined>;
+    readonly value: v.ObjectSchema<{
+      readonly side: v.EnumSchema<typeof Side, undefined>;
+      readonly durationMs: v.BigintSchema<undefined>;
+      readonly sliceIntervalMs: v.BigintSchema<undefined>;
+      readonly execution: v.VariantSchema<"case", [v.ObjectSchema<{
+        readonly case: v.LiteralSchema<"marketIoc", undefined>;
+        readonly value: v.ObjectSchema<{}, undefined>;
+      }, undefined>, v.ObjectSchema<{
+        readonly case: v.LiteralSchema<"limitGtc", undefined>;
+        readonly value: v.ObjectSchema<{
+          readonly priceTicks: v.BigintSchema<undefined>;
+        }, undefined>;
+      }, undefined>, v.ObjectSchema<{
+        readonly case: v.UndefinedSchema<undefined>;
+        readonly value: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+      }, undefined>], undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly case: v.LiteralSchema<"ladder", undefined>;
+    readonly value: v.ObjectSchema<{
+      readonly side: v.EnumSchema<typeof Side, undefined>;
+      readonly priceMinTicks: v.BigintSchema<undefined>;
+      readonly priceMaxTicks: v.BigintSchema<undefined>;
+      readonly levels: v.NumberSchema<undefined>;
+      readonly postOnly: v.BooleanSchema<undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly case: v.UndefinedSchema<undefined>;
+    readonly value: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+  }, undefined>], undefined>;
+  readonly clientTriggerId: v.StringSchema<undefined>;
+  readonly createdAt: v.OptionalSchema<v.ObjectSchema<{
+    readonly seconds: v.BigintSchema<undefined>;
+    readonly nanos: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
+  }, undefined>, undefined>;
+  readonly updatedAt: v.OptionalSchema<v.ObjectSchema<{
+    readonly seconds: v.BigintSchema<undefined>;
+    readonly nanos: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
+  }, undefined>, undefined>;
+  readonly armedAt: v.OptionalSchema<v.ObjectSchema<{
+    readonly seconds: v.BigintSchema<undefined>;
+    readonly nanos: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
+  }, undefined>, undefined>;
+  readonly completedAt: v.OptionalSchema<v.ObjectSchema<{
+    readonly seconds: v.BigintSchema<undefined>;
+    readonly nanos: v.OptionalSchema<v.NumberSchema<undefined>, 0>;
+  }, undefined>, undefined>;
+  readonly runtimeDetails: v.VariantSchema<"case", [v.ObjectSchema<{
+    readonly case: v.LiteralSchema<"stop", undefined>;
+    readonly value: v.ObjectSchema<{
+      readonly triggerPriceTicks: v.BigintSchema<undefined>;
+      readonly triggerPriceSource: v.EnumSchema<typeof TriggerPriceSource, undefined>;
+      readonly triggerDirection: v.EnumSchema<typeof TriggerDirection, undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly case: v.LiteralSchema<"trailing", undefined>;
+    readonly value: v.ObjectSchema<{
+      readonly trailingDistanceTicks: v.BigintSchema<undefined>;
+      readonly activationPriceTicks: v.BigintSchema<undefined>;
+      readonly peakPriceTicks: v.BigintSchema<undefined>;
+      readonly troughPriceTicks: v.BigintSchema<undefined>;
+      readonly trailingDistanceBps: v.NumberSchema<undefined>;
+      readonly maxSlippageTicks: v.NumberSchema<undefined>;
+      readonly maxSlippageBps: v.NumberSchema<undefined>;
+      readonly triggerPriceSource: v.EnumSchema<typeof TriggerPriceSource, undefined>;
+      readonly triggerDirection: v.EnumSchema<typeof TriggerDirection, undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly case: v.LiteralSchema<"twapState", undefined>;
+    readonly value: v.ObjectSchema<{
+      readonly twapDurationMs: v.BigintSchema<undefined>;
+      readonly twapSliceIntervalMs: v.BigintSchema<undefined>;
+      readonly sliceIdx: v.NumberSchema<undefined>;
+      readonly sliceCount: v.NumberSchema<undefined>;
+      readonly executedQtyScaled: v.BigintSchema<undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly case: v.LiteralSchema<"ladderState", undefined>;
+    readonly value: v.ObjectSchema<{
+      readonly ladderPriceMinTicks: v.BigintSchema<undefined>;
+      readonly ladderPriceMaxTicks: v.BigintSchema<undefined>;
+      readonly ladderLevels: v.NumberSchema<undefined>;
+      readonly ladderDistribution: v.EnumSchema<typeof LadderDistribution, undefined>;
+    }, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly case: v.UndefinedSchema<undefined>;
+    readonly value: v.OptionalSchema<v.UndefinedSchema<undefined>, undefined>;
+  }, undefined>], undefined>;
+}, undefined>, v.TransformAction<{
+  triggerId: bigint;
+  subaccountId: bigint;
+  symbolId: number;
+  symbol: string;
+  status: TriggerStatus;
+  parentOrderId?: bigint | undefined;
+  qtyScaled: bigint;
+  feeAsset: FeeAsset;
+  selfTradePreventionMode: SelfTradePreventionMode;
+  configuration: {
+    case: "stopLoss";
+    value: {
+      triggerPriceTicks: bigint;
+      side: Side;
+      child?: {
+        execution: {
+          case: "marketIoc";
+          value: {};
+        } | {
+          case: "limitGtc";
+          value: {
+            priceTicks: bigint;
+            postOnly: boolean;
+          };
+        } | {
+          case: "limitIoc";
+          value: {
+            priceTicks: bigint;
+          };
+        } | {
+          case: "limitFok";
+          value: {
+            priceTicks: bigint;
+          };
+        } | {
+          case: undefined;
+          value?: undefined;
+        };
+      } | undefined;
+    };
+  } | {
+    case: "takeProfit";
+    value: {
+      triggerPriceTicks: bigint;
+      side: Side;
+      child?: {
+        execution: {
+          case: "marketIoc";
+          value: {};
+        } | {
+          case: "limitGtc";
+          value: {
+            priceTicks: bigint;
+            postOnly: boolean;
+          };
+        } | {
+          case: "limitIoc";
+          value: {
+            priceTicks: bigint;
+          };
+        } | {
+          case: "limitFok";
+          value: {
+            priceTicks: bigint;
+          };
+        } | {
+          case: undefined;
+          value?: undefined;
+        };
+      } | undefined;
+    };
+  } | {
+    case: "trailingStop";
+    value: {
+      trailingDistance: {
+        case: "trailingDistanceTicks";
+        value: bigint;
+      } | {
+        case: "trailingDistanceBps";
+        value: number;
+      } | {
+        case: undefined;
+        value?: undefined;
+      };
+      activationPriceTicks: bigint;
+      maxSlippage: {
+        case: "maxSlippageTicks";
+        value: number;
+      } | {
+        case: "maxSlippageBps";
+        value: number;
+      } | {
+        case: undefined;
+        value?: undefined;
+      };
+      side: Side;
+    };
+  } | {
+    case: "twap";
+    value: {
+      side: Side;
+      durationMs: bigint;
+      sliceIntervalMs: bigint;
+      execution: {
+        case: "marketIoc";
+        value: {};
+      } | {
+        case: "limitGtc";
+        value: {
+          priceTicks: bigint;
+        };
+      } | {
+        case: undefined;
+        value?: undefined;
+      };
+    };
+  } | {
+    case: "ladder";
+    value: {
+      side: Side;
+      priceMinTicks: bigint;
+      priceMaxTicks: bigint;
+      levels: number;
+      postOnly: boolean;
+    };
+  } | {
+    case: undefined;
+    value?: undefined;
+  };
+  clientTriggerId: string;
+  createdAt?: {
+    seconds: bigint;
+    nanos: number;
+  } | undefined;
+  updatedAt?: {
+    seconds: bigint;
+    nanos: number;
+  } | undefined;
+  armedAt?: {
+    seconds: bigint;
+    nanos: number;
+  } | undefined;
+  completedAt?: {
+    seconds: bigint;
+    nanos: number;
+  } | undefined;
+  runtimeDetails: {
+    case: "stop";
+    value: {
+      triggerPriceTicks: bigint;
+      triggerPriceSource: TriggerPriceSource;
+      triggerDirection: TriggerDirection;
+    };
+  } | {
+    case: "trailing";
+    value: {
+      trailingDistanceTicks: bigint;
+      activationPriceTicks: bigint;
+      peakPriceTicks: bigint;
+      troughPriceTicks: bigint;
+      trailingDistanceBps: number;
+      maxSlippageTicks: number;
+      maxSlippageBps: number;
+      triggerPriceSource: TriggerPriceSource;
+      triggerDirection: TriggerDirection;
+    };
+  } | {
+    case: "twapState";
+    value: {
+      twapDurationMs: bigint;
+      twapSliceIntervalMs: bigint;
+      sliceIdx: number;
+      sliceCount: number;
+      executedQtyScaled: bigint;
+    };
+  } | {
+    case: "ladderState";
+    value: {
+      ladderPriceMinTicks: bigint;
+      ladderPriceMaxTicks: bigint;
+      ladderLevels: number;
+      ladderDistribution: LadderDistribution;
+    };
+  } | {
+    case: undefined;
+    value?: undefined;
+  };
+}, {
+  triggerId: string;
+  subaccountId: string;
+  symbolId: number;
+  symbol: string;
+  status: "unspecified" | "completed" | "failed" | "cancelled" | "created" | "armed" | "running" | "paused";
+  parentOrderId: string | undefined;
+  qty: string;
+  feeAsset: "unspecified" | "quote" | "base";
+  selfTradePreventionMode: "unspecified" | "expire_taker" | "expire_maker" | "expire_both";
+  configuration: {
+    type: "stop_loss" | "take_profit";
+    side: "unspecified" | "buy" | "sell";
+    triggerPrice: string;
+    execution: {
+      readonly type: "market_ioc";
+      readonly price?: undefined;
+      readonly postOnly?: undefined;
+    } | {
+      readonly type: "limit_gtc";
+      readonly price: string;
+      readonly postOnly: boolean;
+    } | {
+      readonly type: "limit_ioc";
+      readonly price: string;
+      readonly postOnly?: undefined;
+    } | {
+      readonly type: "limit_fok";
+      readonly price: string;
+      readonly postOnly?: undefined;
+    } | {
+      readonly type: "unspecified";
+      readonly price?: undefined;
+      readonly postOnly?: undefined;
+    };
+    trailingDistance?: undefined;
+    activationPrice?: undefined;
+    maxSlippage?: undefined;
+    durationMs?: undefined;
+    sliceIntervalMs?: undefined;
+    priceMin?: undefined;
+    priceMax?: undefined;
+    levels?: undefined;
+    readonly postOnly?: undefined;
+  } | {
+    type: "trailing_stop";
+    side: "unspecified" | "buy" | "sell";
+    trailingDistance: {
+      kind: "distance";
+      distance: string;
+      bps?: undefined;
+    } | {
+      kind: "bps";
+      bps: number;
+      distance?: undefined;
+    } | {
+      kind: "unspecified";
+      distance?: undefined;
+      bps?: undefined;
+    };
+    activationPrice: string | undefined;
+    maxSlippage: {
+      kind: "slippage";
+      slippage: string;
+      bps?: undefined;
+    } | {
+      kind: "bps";
+      bps: number;
+      slippage?: undefined;
+    } | {
+      kind: "none";
+      slippage?: undefined;
+      bps?: undefined;
+    };
+    triggerPrice?: undefined;
+    execution?: undefined;
+    durationMs?: undefined;
+    sliceIntervalMs?: undefined;
+    priceMin?: undefined;
+    priceMax?: undefined;
+    levels?: undefined;
+    readonly postOnly?: undefined;
+  } | {
+    type: "twap";
+    side: "unspecified" | "buy" | "sell";
+    durationMs: number;
+    sliceIntervalMs: number;
+    execution: {
+      readonly type: "market_ioc";
+      readonly price?: undefined;
+    } | {
+      readonly type: "limit_gtc";
+      readonly price: string;
+    } | {
+      readonly type: "unspecified";
+      readonly price?: undefined;
+    };
+    triggerPrice?: undefined;
+    trailingDistance?: undefined;
+    activationPrice?: undefined;
+    maxSlippage?: undefined;
+    priceMin?: undefined;
+    priceMax?: undefined;
+    levels?: undefined;
+    readonly postOnly?: undefined;
+  } | {
+    type: "ladder";
+    side: "unspecified" | "buy" | "sell";
+    priceMin: string;
+    priceMax: string;
+    levels: number;
+    postOnly: boolean;
+    triggerPrice?: undefined;
+    execution?: undefined;
+    trailingDistance?: undefined;
+    activationPrice?: undefined;
+    maxSlippage?: undefined;
+    durationMs?: undefined;
+    sliceIntervalMs?: undefined;
+  } | {
+    type: "unspecified";
+    side?: undefined;
+    triggerPrice?: undefined;
+    execution?: undefined;
+    trailingDistance?: undefined;
+    activationPrice?: undefined;
+    maxSlippage?: undefined;
+    durationMs?: undefined;
+    sliceIntervalMs?: undefined;
+    priceMin?: undefined;
+    priceMax?: undefined;
+    levels?: undefined;
+    readonly postOnly?: undefined;
+  };
+  clientTriggerId: string;
+  createdTs: number | undefined;
+  updatedTs: number | undefined;
+  armedTs: number | undefined;
+  completedTs: number | undefined;
+  runtimeDetails: TriggerDetailsOutput;
+}>]>;
+type Trigger = v.InferOutput<ReturnType<typeof createTriggerSchema>>;
+declare function createTriggerEventSchema(scales: SdkScales): v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly triggerId: v.BigintSchema<undefined>;
+  readonly subaccountId: v.BigintSchema<undefined>;
+  readonly symbolId: v.NumberSchema<undefined>;
+  readonly triggerType: v.EnumSchema<typeof TriggerType, undefined>;
+  readonly eventType: v.EnumSchema<typeof TriggerEventType, undefined>;
+  readonly tsNs: v.BigintSchema<undefined>;
+  readonly childSeq: v.NumberSchema<undefined>;
+  readonly childOrderId: v.BigintSchema<undefined>;
+  readonly firePriceTicks: v.BigintSchema<undefined>;
+  readonly reason: v.StringSchema<undefined>;
+}, undefined>, v.TransformAction<{
+  triggerId: bigint;
+  subaccountId: bigint;
+  symbolId: number;
+  triggerType: TriggerType;
+  eventType: TriggerEventType;
+  tsNs: bigint;
+  childSeq: number;
+  childOrderId: bigint;
+  firePriceTicks: bigint;
+  reason: string;
+}, {
+  triggerId: string;
+  subaccountId: string;
+  symbolId: number;
+  triggerType: "unspecified" | "twap" | "ladder" | "stop_loss" | "take_profit" | "trailing_stop";
+  eventType: "unspecified" | "updated" | "fired" | "canceled";
+  ts: number;
+  childSeq: number;
+  childOrderId: string | undefined;
+  firePrice: string | undefined;
+  reason: string | undefined;
+}>]>;
+type TriggerEvent = v.InferOutput<ReturnType<typeof createTriggerEventSchema>>;
+type ListTriggerEventsResult = {
+  events: TriggerEvent[];
+  nextPageToken: string;
+};
+//#endregion
+export { CancelTriggerResult, CancelTriggerResultSchema, CreateTriggerResult, CreateTriggerResultSchema, LadderDetailsOutput, ListTriggerEventsResult, ModifyTriggerResult, ModifyTriggerResultSchema, PauseTriggerResult, PauseTriggerResultSchema, ResumeTriggerResult, ResumeTriggerResultSchema, StopDetailsOutput, TrailingDetailsOutput, Trigger, TriggerDetailsOutput, TriggerEvent, TwapDetailsOutput, createTriggerEventSchema, createTriggerSchema };
+//# sourceMappingURL=triggers-output.schemas.d.ts.map

package/dist/services/triggers/triggers-output.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triggers-output.schemas.d.ts","names":[],"sources":["../../../src/services/triggers/triggers-output.schemas.ts"],"mappings":";;;;;KAyBK;KAEA;KAEA;cA2BQ,2BAAyB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;KAc1B,sBAAsB,EAAE,mBAAmB;cAE1C,2BAAyB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;KAE1B,sBAAsB,EAAE,mBAAmB;cAE1C,2BAAyB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;KAE1B,sBAAsB,EAAE,mBAAmB;cAE1C,0BAAwB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;KACzB,qBAAqB,EAAE,mBAAmB;cAEzC,2BAAyB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;KAC1B,sBAAsB,EAAE,mBAAmB;KA2Q3C;EACR;EACA;EACA,oBAAoB;EACpB,kBAAkB;;KAGV;EACR;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA,oBAAoB;EACpB,kBAAkB;;KAGV;EACR;EACA;EACA;EACA;EACA;;EAEA;;KAGQ;EACR;EACA;EACA;EACA;EACA,oBAAoB;;KAGZ,uBACN,oBACA,wBACA,oBACA;EACE;;iBAyGQ,oBAAoB,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwDzC,UAAU,EAAE,YAAY,kBAAkB;iBAEtC,yBAAyB,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0C9C,eAAe,EAAE,YAAY,kBAAkB;KAE/C;EACR,QAAQ;EACR"}