@pear-protocol/types 0.0.1

package/dist/schedule/payloads.js

@@ -0,0 +1,102 @@
+import { z } from 'zod';
+import { UnsignedDecimalString, Side } from '../common/schema';
+import { InstrumentId } from '../instrument';
+import { ScheduleSliceMode } from './entities';
+
+const SliceInterval = z.int().min(6e4).max(26784e5);
+const TWAPSliceOpenLeg = z.object({
+  /**
+   * Instrument ID
+   */
+  symbol: InstrumentId,
+  /**
+   * Direction to take
+   */
+  side: Side,
+  /**
+   * Mode to interpret the step amount
+   * @example QUANTITY: 0.001 means 0.001 BTC units
+   * @example USD: 100 means $100 USD
+   */
+  mode: ScheduleSliceMode,
+  /**
+   * Step amount for each slice depending on the mode
+   */
+  stepAmount: UnsignedDecimalString
+});
+const TWAPSliceCloseLeg = z.object({
+  /**
+   * Instrument ID
+   */
+  symbol: InstrumentId,
+  /**
+   * Step amount for each slice in base units
+   */
+  stepAmount: UnsignedDecimalString
+});
+const BaseSchedule = z.object({
+  /**
+   * Start at date
+   */
+  startAt: z.coerce.date().optional().default(/* @__PURE__ */ new Date()),
+  /**
+   * End at date
+   */
+  endAt: z.coerce.date().optional().default(new Date(Date.now() + 30 * 24 * 60 * 60 * 1e3))
+  // 30 days from now
+});
+const CreateTWAPOpen = BaseSchedule.extend({
+  /**
+   * Strategy
+   */
+  strategy: z.literal("TWAP"),
+  /**
+   * Intent
+   */
+  intent: z.literal("OPEN"),
+  /**
+   * Execution type
+   */
+  executionType: z.literal("MARKET"),
+  /**
+   * Step configuration for each leg
+   */
+  sliceLegs: z.array(TWAPSliceOpenLeg),
+  /**
+   * Target notional
+   */
+  targetNotional: UnsignedDecimalString,
+  /**
+   * Slice interval in milliseconds
+   */
+  sliceIntervalMs: SliceInterval
+});
+const CreateTWAPClose = BaseSchedule.extend({
+  /**
+   * Strategy
+   */
+  strategy: z.literal("TWAP"),
+  /**
+   * Intent
+   */
+  intent: z.literal("CLOSE"),
+  /**
+   * Execution type
+   */
+  executionType: z.literal("MARKET"),
+  /**
+   * Step configuration for each leg
+   */
+  sliceLegs: z.array(TWAPSliceCloseLeg),
+  /**
+   * Position UUID
+   */
+  positionId: z.uuid(),
+  /**
+   * Slice interval in milliseconds
+   */
+  sliceIntervalMs: SliceInterval
+});
+const CreateSchedule = z.discriminatedUnion("intent", [CreateTWAPOpen, CreateTWAPClose]);
+
+export { CreateSchedule };

package/dist/schedule/queries.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+export declare const ScheduleListParams: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<number>>>;
+    cursor: z.ZodOptional<z.ZodString>;
+    connector: z.ZodOptional<z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+        binanceusdm: "binanceusdm";
+        bybit: "bybit";
+        okx: "okx";
+    }>>;
+    status: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[] | (("CANCELLED" | "ACTIVE" | "COMPLETED")[] & any[]) | undefined, ("CANCELLED" | "ACTIVE" | "COMPLETED")[]>, z.ZodArray<z.ZodEnum<{
+        CANCELLED: "CANCELLED";
+        ACTIVE: "ACTIVE";
+        COMPLETED: "COMPLETED";
+    }>>>>;
+}, z.core.$strip>;
+export type ScheduleListParamsInput = z.input<typeof ScheduleListParams>;
+export type ScheduleListParams = z.output<typeof ScheduleListParams>;

package/dist/schedule/queries.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { normalizeArray, CursorFindParams } from '../common';
+import { Connector } from '../connector';
+
+const StatusEnum = z.enum(["ACTIVE", "COMPLETED", "CANCELLED"]);
+const StatusArray = z.preprocess((arg) => normalizeArray(arg), z.array(StatusEnum));
+const ScheduleListParams = CursorFindParams.extend({
+  connector: Connector.optional(),
+  status: StatusArray.optional()
+});
+
+export { ScheduleListParams };

package/dist/schedule/responses.d.ts

@@ -0,0 +1,279 @@
+import { z } from 'zod';
+export declare const ScheduleListResponse: z.ZodObject<{
+    limit: z.ZodNumber;
+    nextCursor: z.ZodUnion<[z.ZodString, z.ZodUndefined]>;
+    schedules: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binanceusdm: "binanceusdm";
+            bybit: "bybit";
+            okx: "okx";
+        }>;
+        status: z.ZodEnum<{
+            CANCELLED: "CANCELLED";
+            ACTIVE: "ACTIVE";
+            COMPLETED: "COMPLETED";
+            FAILED: "FAILED";
+        }>;
+        positionKey: z.ZodString;
+        executionType: z.ZodEnum<{
+            MARKET: "MARKET";
+        }>;
+        lastSliceAt: z.ZodOptional<z.ZodString>;
+        startAt: z.ZodString;
+        endAt: z.ZodString;
+        cancelledAt: z.ZodOptional<z.ZodString>;
+        cancelledReason: z.ZodOptional<z.ZodEnum<{
+            USER: "USER";
+            POSITION_CLOSED: "POSITION_CLOSED";
+            SYSTEM: "SYSTEM";
+        }>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        fills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            cloid: z.ZodOptional<z.ZodUUID>;
+            tradeAccountId: z.ZodUUID;
+            symbol: z.ZodString;
+            positionId: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binanceusdm: "binanceusdm";
+                bybit: "bybit";
+                okx: "okx";
+            }>;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            reduceOnly: z.ZodBoolean;
+            quantity: z.ZodString;
+            price: z.ZodString;
+            usd: z.ZodString;
+            fee: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodString;
+        }, z.core.$strip>>>;
+        strategy: z.ZodLiteral<"TWAP">;
+        intent: z.ZodLiteral<"OPEN">;
+        sliceIntervalMs: z.ZodNumber;
+        sliceLegs: z.ZodArray<z.ZodObject<{
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            mode: z.ZodEnum<{
+                QUANTITY: "QUANTITY";
+                USD: "USD";
+            }>;
+            stepAmount: z.ZodString;
+        }, z.core.$strip>>;
+        targetNotional: z.ZodString;
+        remainingNotional: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binanceusdm: "binanceusdm";
+            bybit: "bybit";
+            okx: "okx";
+        }>;
+        status: z.ZodEnum<{
+            CANCELLED: "CANCELLED";
+            ACTIVE: "ACTIVE";
+            COMPLETED: "COMPLETED";
+            FAILED: "FAILED";
+        }>;
+        positionKey: z.ZodString;
+        executionType: z.ZodEnum<{
+            MARKET: "MARKET";
+        }>;
+        lastSliceAt: z.ZodOptional<z.ZodString>;
+        startAt: z.ZodString;
+        endAt: z.ZodString;
+        cancelledAt: z.ZodOptional<z.ZodString>;
+        cancelledReason: z.ZodOptional<z.ZodEnum<{
+            USER: "USER";
+            POSITION_CLOSED: "POSITION_CLOSED";
+            SYSTEM: "SYSTEM";
+        }>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        fills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            cloid: z.ZodOptional<z.ZodUUID>;
+            tradeAccountId: z.ZodUUID;
+            symbol: z.ZodString;
+            positionId: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binanceusdm: "binanceusdm";
+                bybit: "bybit";
+                okx: "okx";
+            }>;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            reduceOnly: z.ZodBoolean;
+            quantity: z.ZodString;
+            price: z.ZodString;
+            usd: z.ZodString;
+            fee: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodString;
+        }, z.core.$strip>>>;
+        strategy: z.ZodLiteral<"TWAP">;
+        intent: z.ZodLiteral<"CLOSE">;
+        sliceIntervalMs: z.ZodNumber;
+        positionId: z.ZodUUID;
+        sliceLegs: z.ZodArray<z.ZodObject<{
+            symbol: z.ZodString;
+            stepAmount: z.ZodString;
+        }, z.core.$strip>>;
+        initialExposure: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>], "intent">>;
+}, z.core.$strip>;
+export type ScheduleListResponse = z.output<typeof ScheduleListResponse>;
+export declare const CreateScheduleResponse: z.ZodObject<{
+    schedule: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        id: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binanceusdm: "binanceusdm";
+            bybit: "bybit";
+            okx: "okx";
+        }>;
+        status: z.ZodEnum<{
+            CANCELLED: "CANCELLED";
+            ACTIVE: "ACTIVE";
+            COMPLETED: "COMPLETED";
+            FAILED: "FAILED";
+        }>;
+        positionKey: z.ZodString;
+        executionType: z.ZodEnum<{
+            MARKET: "MARKET";
+        }>;
+        lastSliceAt: z.ZodOptional<z.ZodString>;
+        startAt: z.ZodString;
+        endAt: z.ZodString;
+        cancelledAt: z.ZodOptional<z.ZodString>;
+        cancelledReason: z.ZodOptional<z.ZodEnum<{
+            USER: "USER";
+            POSITION_CLOSED: "POSITION_CLOSED";
+            SYSTEM: "SYSTEM";
+        }>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        fills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            cloid: z.ZodOptional<z.ZodUUID>;
+            tradeAccountId: z.ZodUUID;
+            symbol: z.ZodString;
+            positionId: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binanceusdm: "binanceusdm";
+                bybit: "bybit";
+                okx: "okx";
+            }>;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            reduceOnly: z.ZodBoolean;
+            quantity: z.ZodString;
+            price: z.ZodString;
+            usd: z.ZodString;
+            fee: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodString;
+        }, z.core.$strip>>>;
+        strategy: z.ZodLiteral<"TWAP">;
+        intent: z.ZodLiteral<"OPEN">;
+        sliceIntervalMs: z.ZodNumber;
+        sliceLegs: z.ZodArray<z.ZodObject<{
+            symbol: z.ZodString;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            mode: z.ZodEnum<{
+                QUANTITY: "QUANTITY";
+                USD: "USD";
+            }>;
+            stepAmount: z.ZodString;
+        }, z.core.$strip>>;
+        targetNotional: z.ZodString;
+        remainingNotional: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        id: z.ZodUUID;
+        connector: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+            binanceusdm: "binanceusdm";
+            bybit: "bybit";
+            okx: "okx";
+        }>;
+        status: z.ZodEnum<{
+            CANCELLED: "CANCELLED";
+            ACTIVE: "ACTIVE";
+            COMPLETED: "COMPLETED";
+            FAILED: "FAILED";
+        }>;
+        positionKey: z.ZodString;
+        executionType: z.ZodEnum<{
+            MARKET: "MARKET";
+        }>;
+        lastSliceAt: z.ZodOptional<z.ZodString>;
+        startAt: z.ZodString;
+        endAt: z.ZodString;
+        cancelledAt: z.ZodOptional<z.ZodString>;
+        cancelledReason: z.ZodOptional<z.ZodEnum<{
+            USER: "USER";
+            POSITION_CLOSED: "POSITION_CLOSED";
+            SYSTEM: "SYSTEM";
+        }>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        fills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            cloid: z.ZodOptional<z.ZodUUID>;
+            tradeAccountId: z.ZodUUID;
+            symbol: z.ZodString;
+            positionId: z.ZodUUID;
+            connector: z.ZodEnum<{
+                hyperliquid: "hyperliquid";
+                binanceusdm: "binanceusdm";
+                bybit: "bybit";
+                okx: "okx";
+            }>;
+            side: z.ZodEnum<{
+                BUY: "BUY";
+                SELL: "SELL";
+            }>;
+            reduceOnly: z.ZodBoolean;
+            quantity: z.ZodString;
+            price: z.ZodString;
+            usd: z.ZodString;
+            fee: z.ZodOptional<z.ZodString>;
+            timestamp: z.ZodString;
+        }, z.core.$strip>>>;
+        strategy: z.ZodLiteral<"TWAP">;
+        intent: z.ZodLiteral<"CLOSE">;
+        sliceIntervalMs: z.ZodNumber;
+        positionId: z.ZodUUID;
+        sliceLegs: z.ZodArray<z.ZodObject<{
+            symbol: z.ZodString;
+            stepAmount: z.ZodString;
+        }, z.core.$strip>>;
+        initialExposure: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strip>], "intent">;
+}, z.core.$strip>;
+export type CreateScheduleResponse = z.output<typeof CreateScheduleResponse>;
+export declare const CancelScheduleResponse: z.ZodObject<{
+    id: z.ZodUUID;
+}, z.core.$strip>;
+export type CancelScheduleResponse = z.output<typeof CancelScheduleResponse>;
+export declare const CancelAllSchedulesResponse: z.ZodObject<{
+    ids: z.ZodArray<z.ZodUUID>;
+}, z.core.$strip>;
+export type CancelAllSchedulesResponse = z.output<typeof CancelAllSchedulesResponse>;

package/dist/schedule/responses.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+import { CursorResponse } from '../common';
+import { Schedule } from './entities';
+
+const ScheduleListResponse = CursorResponse.extend({ schedules: z.array(Schedule) });
+const CreateScheduleResponse = z.object({ schedule: Schedule });
+const CancelScheduleResponse = z.object({ id: z.uuid() });
+const CancelAllSchedulesResponse = z.object({ ids: z.array(z.uuid()) });
+
+export { CancelAllSchedulesResponse, CancelScheduleResponse, CreateScheduleResponse, ScheduleListResponse };

package/dist/trade/index.d.ts

@@ -0,0 +1,2 @@
+export * from './payloads';
+export * from './responses';

package/dist/trade/index.js

@@ -0,0 +1,2 @@
+export * from './payloads';
+export * from './responses';

package/dist/trade/payloads.d.ts

@@ -0,0 +1,217 @@
+import { z } from 'zod';
+export declare const CreateMarketOpen: z.ZodObject<{
+    type: z.ZodLiteral<"MARKET">;
+    legs: z.ZodTuple<[z.ZodObject<{
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        mode: z.ZodEnum<{
+            QUANTITY: "QUANTITY";
+            USD: "USD";
+        }>;
+        amount: z.ZodString;
+    }, z.core.$strip>], z.ZodObject<{
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        mode: z.ZodEnum<{
+            QUANTITY: "QUANTITY";
+            USD: "USD";
+        }>;
+        amount: z.ZodString;
+    }, z.core.$strip>>;
+    trigger: z.ZodOptional<z.ZodObject<{
+        intent: z.ZodLiteral<"CLOSE">;
+        type: z.ZodLiteral<"MARKET">;
+        condition: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"position_value_v1">;
+            data: z.ZodObject<{
+                priceSource: z.ZodEnum<{
+                    mid: "mid";
+                    mark: "mark";
+                }>;
+                direction: z.ZodEnum<{
+                    ABOVE: "ABOVE";
+                    BELOW: "BELOW";
+                }>;
+                threshold: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"position_upnl_value_v1">;
+            data: z.ZodObject<{
+                priceSource: z.ZodEnum<{
+                    mid: "mid";
+                    mark: "mark";
+                }>;
+                direction: z.ZodEnum<{
+                    ABOVE: "ABOVE";
+                    BELOW: "BELOW";
+                }>;
+                threshold: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"position_upnl_percentage_v1">;
+            data: z.ZodObject<{
+                priceSource: z.ZodEnum<{
+                    mid: "mid";
+                    mark: "mark";
+                }>;
+                direction: z.ZodEnum<{
+                    ABOVE: "ABOVE";
+                    BELOW: "BELOW";
+                }>;
+                threshold_bps: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const CreateMarketAdjust: z.ZodObject<{
+    type: z.ZodLiteral<"MARKET">;
+    legs: z.ZodTuple<[z.ZodObject<{
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        mode: z.ZodEnum<{
+            QUANTITY: "QUANTITY";
+            USD: "USD";
+        }>;
+        amount: z.ZodString;
+        reduceOnly: z.ZodBoolean;
+    }, z.core.$strip>], z.ZodObject<{
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        mode: z.ZodEnum<{
+            QUANTITY: "QUANTITY";
+            USD: "USD";
+        }>;
+        amount: z.ZodString;
+        reduceOnly: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const CreateMarketClose: z.ZodObject<{
+    type: z.ZodLiteral<"MARKET">;
+}, z.core.$strip>;
+export declare const CreateMarketCloseAll: z.ZodObject<{
+    type: z.ZodLiteral<"MARKET">;
+}, z.core.$strip>;
+export declare const CreateTradeOpen: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"MARKET">;
+    legs: z.ZodTuple<[z.ZodObject<{
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        mode: z.ZodEnum<{
+            QUANTITY: "QUANTITY";
+            USD: "USD";
+        }>;
+        amount: z.ZodString;
+    }, z.core.$strip>], z.ZodObject<{
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        mode: z.ZodEnum<{
+            QUANTITY: "QUANTITY";
+            USD: "USD";
+        }>;
+        amount: z.ZodString;
+    }, z.core.$strip>>;
+    trigger: z.ZodOptional<z.ZodObject<{
+        intent: z.ZodLiteral<"CLOSE">;
+        type: z.ZodLiteral<"MARKET">;
+        condition: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"position_value_v1">;
+            data: z.ZodObject<{
+                priceSource: z.ZodEnum<{
+                    mid: "mid";
+                    mark: "mark";
+                }>;
+                direction: z.ZodEnum<{
+                    ABOVE: "ABOVE";
+                    BELOW: "BELOW";
+                }>;
+                threshold: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"position_upnl_value_v1">;
+            data: z.ZodObject<{
+                priceSource: z.ZodEnum<{
+                    mid: "mid";
+                    mark: "mark";
+                }>;
+                direction: z.ZodEnum<{
+                    ABOVE: "ABOVE";
+                    BELOW: "BELOW";
+                }>;
+                threshold: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"position_upnl_percentage_v1">;
+            data: z.ZodObject<{
+                priceSource: z.ZodEnum<{
+                    mid: "mid";
+                    mark: "mark";
+                }>;
+                direction: z.ZodEnum<{
+                    ABOVE: "ABOVE";
+                    BELOW: "BELOW";
+                }>;
+                threshold_bps: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>], "type">;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">;
+export declare const CreateTradeAdjust: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"MARKET">;
+    legs: z.ZodTuple<[z.ZodObject<{
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        mode: z.ZodEnum<{
+            QUANTITY: "QUANTITY";
+            USD: "USD";
+        }>;
+        amount: z.ZodString;
+        reduceOnly: z.ZodBoolean;
+    }, z.core.$strip>], z.ZodObject<{
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        mode: z.ZodEnum<{
+            QUANTITY: "QUANTITY";
+            USD: "USD";
+        }>;
+        amount: z.ZodString;
+        reduceOnly: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">;
+export declare const CreateTradeClose: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"MARKET">;
+}, z.core.$strip>], "type">;
+export declare const CreateTradeCloseAll: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"MARKET">;
+}, z.core.$strip>], "type">;
+export type CreateMarketOpen = z.output<typeof CreateMarketOpen>;
+export type CreateMarketAdjust = z.output<typeof CreateMarketAdjust>;
+export type CreateMarketClose = z.output<typeof CreateMarketClose>;
+export type CreateMarketCloseAll = z.output<typeof CreateMarketCloseAll>;
+export type CreateTradeOpen = z.output<typeof CreateTradeOpen>;
+export type CreateTradeAdjust = z.output<typeof CreateTradeAdjust>;
+export type CreateTradeClose = z.output<typeof CreateTradeClose>;
+export type CreateTradeCloseAll = z.output<typeof CreateTradeCloseAll>;

package/dist/trade/payloads.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { RefineMinimumOneSymbol, RefineUniqueSymbols } from '../common/refinement';
+import { TradeLegPostOnly, TradeLeg } from '../common/trade-legs';
+import { AttachTriggerMarketClose } from '../trigger';
+
+const CreateMarketOpen = z.object({
+  type: z.literal("MARKET"),
+  /**
+   * Requested legs
+   */
+  legs: z.tuple([TradeLegPostOnly]).rest(TradeLegPostOnly).superRefine(RefineMinimumOneSymbol).superRefine(RefineUniqueSymbols).describe("Array of legs to make up the exposure"),
+  /**
+   * Close trigger to attach to the execution
+   */
+  trigger: AttachTriggerMarketClose.optional()
+});
+const CreateMarketAdjust = z.object({
+  type: z.literal("MARKET"),
+  /**
+   * Requested legs
+   */
+  legs: z.tuple([TradeLeg]).rest(TradeLeg).superRefine(RefineMinimumOneSymbol).superRefine(RefineUniqueSymbols).describe("Array of legs to modify the position")
+});
+const CreateMarketClose = z.object({
+  type: z.literal("MARKET")
+});
+const CreateMarketCloseAll = z.object({
+  type: z.literal("MARKET")
+});
+const CreateTradeOpen = z.discriminatedUnion("type", [CreateMarketOpen]);
+const CreateTradeAdjust = z.discriminatedUnion("type", [CreateMarketAdjust]);
+const CreateTradeClose = z.discriminatedUnion("type", [CreateMarketClose]);
+const CreateTradeCloseAll = z.discriminatedUnion("type", [CreateMarketCloseAll]);
+
+export { CreateMarketAdjust, CreateMarketClose, CreateMarketCloseAll, CreateMarketOpen, CreateTradeAdjust, CreateTradeClose, CreateTradeCloseAll, CreateTradeOpen };