@polyester/sdk 0.27.2 → 0.28.0

package/dist/services/market-data/market-data.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"market-data.schemas.js","names":[],"sources":["../../../src/services/market-data/market-data.schemas.ts"],"sourcesContent":["import * as v from \"valibot\";\nimport { SideSchema, SymbolIdInputSchema } from \"../shared.js\";\nimport {\n    PAIR_STATUSES,\n    type AssetConfig,\n    type PairConfig,\n    type PairMarketDataConfig,\n    type PairStatus,\n    type SpotConfig,\n} from \"../../shared/catalog-config.js\";\nimport { tsNsToMs } from \"../../utils/time.js\";\nimport { timestampToMs, tsNsToTimestamp } from \"../../utils/timestamp.js\";\nimport { optionalUint64DecimalFilterSchema } from \"../../shared/schemas.js\";\nimport { scaledToDecimalOutput, type SdkScales } from \"../../shared/decimal-surface.js\";\nimport { PairStatusCodec, SideFilterCodec } from \"./market-data.codecs.js\";\n\nexport type { AssetConfig, PairConfig, PairMarketDataConfig, PairStatus, SpotConfig };\nexport { PAIR_STATUSES };\n\nexport function createMarketTradeSchema(scales: SdkScales) {\n    return v.pipe(\n        v.object({\n            symbolId: v.number(),\n            matchId: v.bigint(),\n            isBuy: v.boolean(),\n            priceTicks: v.bigint(),\n            qtyScaled: v.bigint(),\n            tsNs: v.optional(v.bigint(), 0n),\n        }),\n        v.transform((t) => {\n            const sideLabel: v.InferOutput<typeof SideSchema> = t.isBuy ? \"buy\" : \"sell\";\n            return {\n                symbolId: t.symbolId,\n                matchId: t.matchId.toString(),\n                isBuy: t.isBuy,\n                sideLabel,\n                qty: scaledToDecimalOutput(t.qtyScaled, scales.baseQty(t.symbolId)),\n                price: scaledToDecimalOutput(t.priceTicks, scales.price()),\n                tsNs: t.tsNs.toString(),\n                tsMs: tsNsToMs(t.tsNs),\n            };\n        }),\n    );\n}\n\nexport type MarketTrade = v.InferOutput<ReturnType<typeof createMarketTradeSchema>>;\n\nexport const GetMarketTradesInputSchema = v.pipe(\n    v.object({\n        symbolId: SymbolIdInputSchema,\n        side: v.optional(SideSchema),\n        startTsNs: optionalUint64DecimalFilterSchema(\"startTsNs\"),\n        endTsNs: optionalUint64DecimalFilterSchema(\"endTsNs\"),\n        limit: v.optional(v.pipe(v.number(), v.integer(), v.gtValue(0), v.maxValue(1_000))),\n        pageToken: v.optional(v.pipe(v.string(), v.trim()), \"\"),\n    }),\n    v.transform((input) => ({\n        symbolId: input.symbolId,\n        side: input.side ? SideFilterCodec.inputToProto[input.side] : undefined,\n        startTime: tsNsToTimestamp(input.startTsNs),\n        endTime: tsNsToTimestamp(input.endTsNs),\n        limit: input.limit,\n        pageToken: input.pageToken,\n    })),\n);\n\nexport function createGetMarketTradesInputSchema() {\n    return GetMarketTradesInputSchema;\n}\n\nexport type GetMarketTradesInput = v.InferInput<\n    ReturnType<typeof createGetMarketTradesInputSchema>\n>;\nexport type GetMarketTradesRequest = v.InferOutput<\n    ReturnType<typeof createGetMarketTradesInputSchema>\n>;\n\n/** Integer wire scales are protocol-bounded to 0..18 decimal places. */\nconst WireScaleSchema = v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(18));\n\nexport const AssetConfigSchema = v.pipe(\n    v.object({\n        /**\n         * Asset identifier/symbol, e.g. 'USDT', 'BTC'.\n         */\n        asset: v.string(),\n        /**\n         * Internal ledger identifier for settlement systems.\n         */\n        ledgerId: v.number(),\n        /**\n         * The friendly display name for the asset (e.g. 'Bitcoin').\n         */\n        name: v.string(),\n        /**\n         * UI-only display precision for asset amounts/balances.\n         */\n        quantityDisplayDecimals: v.number(),\n        /**\n         * Fixed integer scaling for quantities/amounts in this asset (0..18).\n         */\n        quantityScale: v.number(),\n        /**\n         * Integer scale for public candle and market-overview base volume (0..18).\n         */\n        marketDataVolumeScale: v.optional(WireScaleSchema, 0),\n    }),\n    v.transform((a) => ({\n        symbol: a.asset,\n        ledgerId: a.ledgerId,\n        name: a.name,\n        quantityDisplayDecimals: a.quantityDisplayDecimals,\n        quantityScale: a.quantityScale,\n        marketDataVolumeScale: a.marketDataVolumeScale,\n    })),\n);\n\nexport const PairMarketDataConfigSchema = v.optional(\n    v.object({\n        /**\n         * Available price grouping sizes for the orderbook in quote units.\n         * Allows viewing orders bucketed by larger increments (e.g., [0.01, 0.1, 1, 10]).\n         */\n        orderbookPriceBuckets: v.array(v.number()),\n    }),\n    {\n        orderbookPriceBuckets: [] as number[],\n    },\n);\n\nfunction bpsToPercent(bps: number): number {\n    return bps / 100;\n}\n\nexport const PairConfigSchema = v.pipe(\n    v.object({\n        /**\n         * Internal engine symbol id for the pair.\n         */\n        symbolId: v.number(),\n        /**\n         * Pair symbol string, e.g. 'BTC-USDT'\n         */\n        symbol: v.string(),\n        /**\n         * Base asset symbol, e.g. 'BTC'\n         */\n        baseAsset: v.string(),\n        /**\n         * Quote asset symbol, e.g. 'USDT'\n         */\n        quoteAsset: v.string(),\n        /**\n         * (e.g., \"0.01\") - The smallest price increment allowed. If tick size is 0.01, you can price at $100.00, $100.01, $100.02... but NOT $100.005.\n         */\n        tickSize: v.string(),\n        /**\n         * (e.g., \"0.0001\") - The smallest quantity increment allowed. If step size is 0.0001, you can order 100.0000, 100.0001, 100.0002... but NOT 100.00005.\n         */\n        stepSize: v.string(),\n        /**\n         * (e.g., \"1\") - Minimum order value in quote currency. If it's \"1\" and quote is USD, your order must be worth at least $1. So you can't buy $0.50 worth of something.\n         */\n        minNotionalQuote: v.string(),\n        /**\n         * Minimum quantity you can order in base currency terms. If it's \"0.001\" for BTC, smallest order is 0.001 BTC.\n         */\n        minQtyBase: v.string(),\n\n        /**\n         * Controls whether trading fee can be deducted from what you receive when buying.\n         * Example\n         * - You buy 1 ETH, fee is 0.1%\n         * - if `true`, you receive 0.999 ETH (fee taken from ETH you're getting)\n         * - if `false`, you receive 1 ETH, but you pay the fee separately in the quote currency (e.g., extra USDT)\n         */\n        allowBuyFeeFromBase: v.boolean(),\n        /**\n         * Default market slippage for buy orders in basis points from proto.\n         */\n        defaultMarketSlippageBpsBuy: v.optional(v.number(), 0),\n        /**\n         * Default market slippage for sell orders in basis points from proto.\n         */\n        defaultMarketSlippageBpsSell: v.optional(v.number(), 0),\n        /**\n         * Maximum server/client reference-price drift in basis points from proto.\n         */\n        maxClientRefDriftBps: v.optional(v.number(), 0),\n\n        /**\n         * Market-data configuration for this pair (orderbook bucket sizes, depths).\n         */\n        marketdata: v.optional(PairMarketDataConfigSchema),\n        /**\n         * Base asset quantity scale copied from AssetConfig.quantityScale.\n         */\n        baseQuantityScale: v.number(),\n        /**\n         * Quote asset quantity scale copied from AssetConfig.quantityScale.\n         */\n        quoteQuantityScale: v.number(),\n        /**\n         * Integer scale for composite reference prices in candle responses (0..18).\n         * Primary market and execution prices continue to use scale 6.\n         */\n        referencePriceScale: v.optional(WireScaleSchema, 0),\n        /**\n         * Optional scheduled listing timestamp (UTC).\n         */\n        listingAt: v.pipe(v.optional(v.unknown()), v.transform(timestampToMs)),\n        /**\n         * Optional scheduled delisting timestamp (UTC).\n         */\n        delistingAt: v.pipe(v.optional(v.unknown()), v.transform(timestampToMs)),\n        /**\n         * Operational status of the pair.\n         */\n        status: v.pipe(\n            v.number(),\n            v.transform(\n                (status): PairStatus =>\n                    PairStatusCodec.protoToOutput[\n                        status as keyof typeof PairStatusCodec.protoToOutput\n                    ] ?? \"unknown\",\n            ),\n        ),\n    }),\n    v.transform(\n        ({\n            defaultMarketSlippageBpsBuy,\n            defaultMarketSlippageBpsSell,\n            maxClientRefDriftBps,\n            ...pair\n        }) => ({\n            ...pair,\n            defaultMarketSlippagePctBuy: bpsToPercent(defaultMarketSlippageBpsBuy),\n            defaultMarketSlippagePctSell: bpsToPercent(defaultMarketSlippageBpsSell),\n            maxClientRefDriftPct: bpsToPercent(maxClientRefDriftBps),\n        }),\n    ),\n);\n\nexport const SpotConfigSchema = v.object({\n    assets: v.array(AssetConfigSchema),\n    pairs: v.array(PairConfigSchema),\n    tsSec: v.pipe(\n        v.bigint(),\n        v.transform((v) => Number(v) * 1000),\n    ),\n});\n"],"mappings":";;;;;;;;;AAmBA,SAAgB,wBAAwB,QAAmB;CACvD,OAAO,EAAE,KACL,EAAE,OAAO;EACL,UAAU,EAAE,OAAO;EACnB,SAAS,EAAE,OAAO;EAClB,OAAO,EAAE,QAAQ;EACjB,YAAY,EAAE,OAAO;EACrB,WAAW,EAAE,OAAO;EACpB,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,EAAE;CACnC,CAAC,GACD,EAAE,WAAW,MAAM;EACf,MAAM,YAA8C,EAAE,QAAQ,QAAQ;EACtE,OAAO;GACH,UAAU,EAAE;GACZ,SAAS,EAAE,QAAQ,SAAS;GAC5B,OAAO,EAAE;GACT;GACA,KAAK,sBAAsB,EAAE,WAAW,OAAO,QAAQ,EAAE,QAAQ,CAAC;GAClE,OAAO,sBAAsB,EAAE,YAAY,OAAO,MAAM,CAAC;GACzD,MAAM,EAAE,KAAK,SAAS;GACtB,MAAM,SAAS,EAAE,IAAI;EACzB;CACJ,CAAC,CACL;AACJ;AAIA,MAAa,6BAA6B,EAAE,KACxC,EAAE,OAAO;CACL,UAAU;CACV,MAAM,EAAE,SAAS,UAAU;CAC3B,WAAW,kCAAkC,WAAW;CACxD,SAAS,kCAAkC,SAAS;CACpD,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,GAAG,EAAE,QAAQ,CAAC,GAAG,EAAE,SAAS,GAAK,CAAC,CAAC;CAClF,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE;AAC1D,CAAC,GACD,EAAE,WAAW,WAAW;CACpB,UAAU,MAAM;CAChB,MAAM,MAAM,OAAO,gBAAgB,aAAa,MAAM,QAAQ,KAAA;CAC9D,WAAW,gBAAgB,MAAM,SAAS;CAC1C,SAAS,gBAAgB,MAAM,OAAO;CACtC,OAAO,MAAM;CACb,WAAW,MAAM;AACrB,EAAE,CACN;;AAcA,MAAM,kBAAkB,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,GAAG,EAAE,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,CAAC;AAErF,MAAa,oBAAoB,EAAE,KAC/B,EAAE,OAAO;;;;CAIL,OAAO,EAAE,OAAO;;;;CAIhB,UAAU,EAAE,OAAO;;;;CAInB,MAAM,EAAE,OAAO;;;;CAIf,yBAAyB,EAAE,OAAO;;;;CAIlC,eAAe,EAAE,OAAO;;;;CAIxB,uBAAuB,EAAE,SAAS,iBAAiB,CAAC;AACxD,CAAC,GACD,EAAE,WAAW,OAAO;CAChB,QAAQ,EAAE;CACV,UAAU,EAAE;CACZ,MAAM,EAAE;CACR,yBAAyB,EAAE;CAC3B,eAAe,EAAE;CACjB,uBAAuB,EAAE;AAC7B,EAAE,CACN;AAEA,MAAa,6BAA6B,EAAE,SACxC,EAAE,OAAO;;;;;AAKL,uBAAuB,EAAE,MAAM,EAAE,OAAO,CAAC,EAC7C,CAAC,GACD,EACI,uBAAuB,CAAC,EAC5B,CACJ;AAEA,SAAS,aAAa,KAAqB;CACvC,OAAO,MAAM;AACjB;AAEA,MAAa,mBAAmB,EAAE,KAC9B,EAAE,OAAO;;;;CAIL,UAAU,EAAE,OAAO;;;;CAInB,QAAQ,EAAE,OAAO;;;;CAIjB,WAAW,EAAE,OAAO;;;;CAIpB,YAAY,EAAE,OAAO;;;;CAIrB,UAAU,EAAE,OAAO;;;;CAInB,UAAU,EAAE,OAAO;;;;CAInB,kBAAkB,EAAE,OAAO;;;;CAI3B,YAAY,EAAE,OAAO;;;;;;;;CASrB,qBAAqB,EAAE,QAAQ;;;;CAI/B,6BAA6B,EAAE,SAAS,EAAE,OAAO,GAAG,CAAC;;;;CAIrD,8BAA8B,EAAE,SAAS,EAAE,OAAO,GAAG,CAAC;;;;CAItD,sBAAsB,EAAE,SAAS,EAAE,OAAO,GAAG,CAAC;;;;CAK9C,YAAY,EAAE,SAAS,0BAA0B;;;;CAIjD,mBAAmB,EAAE,OAAO;;;;CAI5B,oBAAoB,EAAE,OAAO;;;;;CAK7B,qBAAqB,EAAE,SAAS,iBAAiB,CAAC;;;;CAIlD,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC,GAAG,EAAE,UAAU,aAAa,CAAC;;;;CAIrE,aAAa,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC,GAAG,EAAE,UAAU,aAAa,CAAC;;;;CAIvE,QAAQ,EAAE,KACN,EAAE,OAAO,GACT,EAAE,WACG,WACG,gBAAgB,cACZ,WACC,SACb,CACJ;AACJ,CAAC,GACD,EAAE,WACG,EACG,6BACA,8BACA,sBACA,GAAG,YACA;CACH,GAAG;CACH,6BAA6B,aAAa,2BAA2B;CACrE,8BAA8B,aAAa,4BAA4B;CACvE,sBAAsB,aAAa,oBAAoB;AAC3D,EACJ,CACJ;AAEA,MAAa,mBAAmB,EAAE,OAAO;CACrC,QAAQ,EAAE,MAAM,iBAAiB;CACjC,OAAO,EAAE,MAAM,gBAAgB;CAC/B,OAAO,EAAE,KACL,EAAE,OAAO,GACT,EAAE,WAAW,MAAM,OAAO,CAAC,IAAI,GAAI,CACvC;AACJ,CAAC"}
+{"version":3,"file":"market-data.schemas.js","names":[],"sources":["../../../src/services/market-data/market-data.schemas.ts"],"sourcesContent":["import * as v from \"valibot\";\nimport { SideSchema, SymbolIdInputSchema } from \"../shared.js\";\nimport {\n    PAIR_STATUSES,\n    type AssetConfig,\n    type PairConfig,\n    type PairMarketDataConfig,\n    type PairStatus,\n    type SpotConfig,\n} from \"../../shared/catalog-config.js\";\nimport { tsNsToMs } from \"../../utils/time.js\";\nimport { timestampToMs, tsNsToTimestamp } from \"../../utils/timestamp.js\";\nimport { optionalUint64DecimalFilterSchema } from \"../../shared/schemas.js\";\nimport { scaledToDecimalOutput, type SdkScales } from \"../../shared/decimal-surface.js\";\nimport { PairStatusCodec, SideFilterCodec } from \"./market-data.codecs.js\";\n\nexport type { AssetConfig, PairConfig, PairMarketDataConfig, PairStatus, SpotConfig };\nexport { PAIR_STATUSES };\n\nexport function createMarketTradeSchema(scales: SdkScales) {\n    return v.pipe(\n        v.object({\n            symbolId: v.number(),\n            matchId: v.bigint(),\n            isBuy: v.boolean(),\n            priceTicks: v.bigint(),\n            qtyScaled: v.bigint(),\n            tsNs: v.optional(v.bigint(), 0n),\n        }),\n        v.transform((t) => {\n            const sideLabel: v.InferOutput<typeof SideSchema> = t.isBuy ? \"buy\" : \"sell\";\n            return {\n                symbolId: t.symbolId,\n                matchId: t.matchId.toString(),\n                isBuy: t.isBuy,\n                sideLabel,\n                qty: scaledToDecimalOutput(t.qtyScaled, scales.baseQty(t.symbolId)),\n                price: scaledToDecimalOutput(t.priceTicks, scales.price()),\n                tsNs: t.tsNs.toString(),\n                tsMs: tsNsToMs(t.tsNs),\n            };\n        }),\n    );\n}\n\nexport type MarketTrade = v.InferOutput<ReturnType<typeof createMarketTradeSchema>>;\n\nexport const GetMarketTradesInputSchema = v.pipe(\n    v.object({\n        symbolId: SymbolIdInputSchema,\n        side: v.optional(SideSchema),\n        startTsNs: optionalUint64DecimalFilterSchema(\"startTsNs\"),\n        endTsNs: optionalUint64DecimalFilterSchema(\"endTsNs\"),\n        limit: v.optional(v.pipe(v.number(), v.integer(), v.gtValue(0), v.maxValue(1_000))),\n        pageToken: v.optional(v.pipe(v.string(), v.trim()), \"\"),\n    }),\n    v.transform((input) => ({\n        symbolId: input.symbolId,\n        side: input.side ? SideFilterCodec.inputToProto[input.side] : undefined,\n        startTime: tsNsToTimestamp(input.startTsNs),\n        endTime: tsNsToTimestamp(input.endTsNs),\n        limit: input.limit,\n        pageToken: input.pageToken,\n    })),\n);\n\nexport function createGetMarketTradesInputSchema() {\n    return GetMarketTradesInputSchema;\n}\n\nexport type GetMarketTradesInput = v.InferInput<\n    ReturnType<typeof createGetMarketTradesInputSchema>\n>;\nexport type GetMarketTradesRequest = v.InferOutput<\n    ReturnType<typeof createGetMarketTradesInputSchema>\n>;\n\n/** Integer wire scales are protocol-bounded to 0..18 decimal places. */\nconst WireScaleSchema = v.pipe(v.number(), v.integer(), v.minValue(0), v.maxValue(18));\n\nexport const AssetConfigSchema = v.pipe(\n    v.object({\n        /**\n         * Asset identifier/symbol, e.g. 'USDT', 'BTC'.\n         */\n        asset: v.string(),\n        /**\n         * Internal ledger identifier for settlement systems.\n         */\n        ledgerId: v.number(),\n        /**\n         * The friendly display name for the asset (e.g. 'Bitcoin').\n         */\n        name: v.string(),\n        /**\n         * UI-only display precision for asset amounts/balances.\n         */\n        quantityDisplayDecimals: v.number(),\n        /**\n         * Fixed integer scaling for quantities/amounts in this asset (0..18).\n         */\n        quantityScale: v.number(),\n        /**\n         * Integer scale for public candle and market-overview base volume (0..18).\n         */\n        marketDataVolumeScale: v.optional(WireScaleSchema, 0),\n    }),\n    v.transform((a) => ({\n        symbol: a.asset,\n        ledgerId: a.ledgerId,\n        name: a.name,\n        quantityDisplayDecimals: a.quantityDisplayDecimals,\n        quantityScale: a.quantityScale,\n        marketDataVolumeScale: a.marketDataVolumeScale,\n    })),\n);\n\nexport const PairMarketDataConfigSchema = v.optional(\n    v.object({\n        /**\n         * Available price grouping sizes for the orderbook in quote units.\n         * Allows viewing orders bucketed by larger increments (e.g., [0.01, 0.1, 1, 10]).\n         */\n        orderbookPriceBuckets: v.array(v.number()),\n    }),\n    {\n        orderbookPriceBuckets: [] as number[],\n    },\n);\n\nfunction bpsToPercent(bps: number): number {\n    return bps / 100;\n}\n\nexport const PairConfigSchema = v.pipe(\n    v.object({\n        /**\n         * Internal engine symbol id for the pair.\n         */\n        symbolId: v.number(),\n        /**\n         * Pair symbol string, e.g. 'BTC-USDT'\n         */\n        symbol: v.string(),\n        /**\n         * Base asset symbol, e.g. 'BTC'\n         */\n        baseAsset: v.string(),\n        /**\n         * Quote asset symbol, e.g. 'USDT'\n         */\n        quoteAsset: v.string(),\n        /**\n         * (e.g., \"0.01\") - The smallest price increment allowed. If tick size is 0.01, you can price at $100.00, $100.01, $100.02... but NOT $100.005.\n         */\n        tickSize: v.string(),\n        /**\n         * (e.g., \"0.0001\") - The smallest quantity increment allowed. If step size is 0.0001, you can order 100.0000, 100.0001, 100.0002... but NOT 100.00005.\n         */\n        stepSize: v.string(),\n        /**\n         * (e.g., \"1\") - Minimum order value in quote currency. If it's \"1\" and quote is USD, your order must be worth at least $1. So you can't buy $0.50 worth of something.\n         */\n        minNotionalQuote: v.string(),\n        /**\n         * Minimum quantity you can order in base currency terms. If it's \"0.001\" for BTC, smallest order is 0.001 BTC.\n         */\n        minQtyBase: v.string(),\n\n        /**\n         * Controls whether trading fee can be deducted from what you receive when buying.\n         * Example\n         * - You buy 1 ETH, fee is 0.1%\n         * - if `true`, you receive 0.999 ETH (fee taken from ETH you're getting)\n         * - if `false`, you receive 1 ETH, but you pay the fee separately in the quote currency (e.g., extra USDT)\n         */\n        allowBuyFeeFromBase: v.boolean(),\n        /**\n         * Default market slippage for buy orders in basis points from proto.\n         */\n        defaultMarketSlippageBpsBuy: v.optional(v.number(), 0),\n        /**\n         * Default market slippage for sell orders in basis points from proto.\n         */\n        defaultMarketSlippageBpsSell: v.optional(v.number(), 0),\n        /**\n         * Maximum server/client reference-price drift in basis points from proto.\n         */\n        maxClientRefDriftBps: v.optional(v.number(), 0),\n\n        /**\n         * Market-data configuration for this pair (orderbook bucket sizes, depths).\n         */\n        marketdata: v.optional(PairMarketDataConfigSchema),\n        /**\n         * Base asset quantity scale copied from AssetConfig.quantityScale.\n         */\n        baseQuantityScale: v.number(),\n        /**\n         * Quote asset quantity scale copied from AssetConfig.quantityScale.\n         */\n        quoteQuantityScale: v.number(),\n        /**\n         * Integer scale for composite reference prices in candle responses (0..18).\n         * Primary market and execution prices use the fixed scale 9.\n         */\n        referencePriceScale: v.optional(WireScaleSchema, 0),\n        /**\n         * Optional scheduled listing timestamp (UTC).\n         */\n        listingAt: v.pipe(v.optional(v.unknown()), v.transform(timestampToMs)),\n        /**\n         * Optional scheduled delisting timestamp (UTC).\n         */\n        delistingAt: v.pipe(v.optional(v.unknown()), v.transform(timestampToMs)),\n        /**\n         * Operational status of the pair.\n         */\n        status: v.pipe(\n            v.number(),\n            v.transform(\n                (status): PairStatus =>\n                    PairStatusCodec.protoToOutput[\n                        status as keyof typeof PairStatusCodec.protoToOutput\n                    ] ?? \"unknown\",\n            ),\n        ),\n    }),\n    v.transform(\n        ({\n            defaultMarketSlippageBpsBuy,\n            defaultMarketSlippageBpsSell,\n            maxClientRefDriftBps,\n            ...pair\n        }) => ({\n            ...pair,\n            defaultMarketSlippagePctBuy: bpsToPercent(defaultMarketSlippageBpsBuy),\n            defaultMarketSlippagePctSell: bpsToPercent(defaultMarketSlippageBpsSell),\n            maxClientRefDriftPct: bpsToPercent(maxClientRefDriftBps),\n        }),\n    ),\n);\n\nexport const SpotConfigSchema = v.object({\n    assets: v.array(AssetConfigSchema),\n    pairs: v.array(PairConfigSchema),\n    tsSec: v.pipe(\n        v.bigint(),\n        v.transform((v) => Number(v) * 1000),\n    ),\n});\n"],"mappings":";;;;;;;;;AAmBA,SAAgB,wBAAwB,QAAmB;CACvD,OAAO,EAAE,KACL,EAAE,OAAO;EACL,UAAU,EAAE,OAAO;EACnB,SAAS,EAAE,OAAO;EAClB,OAAO,EAAE,QAAQ;EACjB,YAAY,EAAE,OAAO;EACrB,WAAW,EAAE,OAAO;EACpB,MAAM,EAAE,SAAS,EAAE,OAAO,GAAG,EAAE;CACnC,CAAC,GACD,EAAE,WAAW,MAAM;EACf,MAAM,YAA8C,EAAE,QAAQ,QAAQ;EACtE,OAAO;GACH,UAAU,EAAE;GACZ,SAAS,EAAE,QAAQ,SAAS;GAC5B,OAAO,EAAE;GACT;GACA,KAAK,sBAAsB,EAAE,WAAW,OAAO,QAAQ,EAAE,QAAQ,CAAC;GAClE,OAAO,sBAAsB,EAAE,YAAY,OAAO,MAAM,CAAC;GACzD,MAAM,EAAE,KAAK,SAAS;GACtB,MAAM,SAAS,EAAE,IAAI;EACzB;CACJ,CAAC,CACL;AACJ;AAIA,MAAa,6BAA6B,EAAE,KACxC,EAAE,OAAO;CACL,UAAU;CACV,MAAM,EAAE,SAAS,UAAU;CAC3B,WAAW,kCAAkC,WAAW;CACxD,SAAS,kCAAkC,SAAS;CACpD,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,GAAG,EAAE,QAAQ,CAAC,GAAG,EAAE,SAAS,GAAK,CAAC,CAAC;CAClF,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE;AAC1D,CAAC,GACD,EAAE,WAAW,WAAW;CACpB,UAAU,MAAM;CAChB,MAAM,MAAM,OAAO,gBAAgB,aAAa,MAAM,QAAQ,KAAA;CAC9D,WAAW,gBAAgB,MAAM,SAAS;CAC1C,SAAS,gBAAgB,MAAM,OAAO;CACtC,OAAO,MAAM;CACb,WAAW,MAAM;AACrB,EAAE,CACN;;AAcA,MAAM,kBAAkB,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,QAAQ,GAAG,EAAE,SAAS,CAAC,GAAG,EAAE,SAAS,EAAE,CAAC;AAErF,MAAa,oBAAoB,EAAE,KAC/B,EAAE,OAAO;;;;CAIL,OAAO,EAAE,OAAO;;;;CAIhB,UAAU,EAAE,OAAO;;;;CAInB,MAAM,EAAE,OAAO;;;;CAIf,yBAAyB,EAAE,OAAO;;;;CAIlC,eAAe,EAAE,OAAO;;;;CAIxB,uBAAuB,EAAE,SAAS,iBAAiB,CAAC;AACxD,CAAC,GACD,EAAE,WAAW,OAAO;CAChB,QAAQ,EAAE;CACV,UAAU,EAAE;CACZ,MAAM,EAAE;CACR,yBAAyB,EAAE;CAC3B,eAAe,EAAE;CACjB,uBAAuB,EAAE;AAC7B,EAAE,CACN;AAEA,MAAa,6BAA6B,EAAE,SACxC,EAAE,OAAO;;;;;AAKL,uBAAuB,EAAE,MAAM,EAAE,OAAO,CAAC,EAC7C,CAAC,GACD,EACI,uBAAuB,CAAC,EAC5B,CACJ;AAEA,SAAS,aAAa,KAAqB;CACvC,OAAO,MAAM;AACjB;AAEA,MAAa,mBAAmB,EAAE,KAC9B,EAAE,OAAO;;;;CAIL,UAAU,EAAE,OAAO;;;;CAInB,QAAQ,EAAE,OAAO;;;;CAIjB,WAAW,EAAE,OAAO;;;;CAIpB,YAAY,EAAE,OAAO;;;;CAIrB,UAAU,EAAE,OAAO;;;;CAInB,UAAU,EAAE,OAAO;;;;CAInB,kBAAkB,EAAE,OAAO;;;;CAI3B,YAAY,EAAE,OAAO;;;;;;;;CASrB,qBAAqB,EAAE,QAAQ;;;;CAI/B,6BAA6B,EAAE,SAAS,EAAE,OAAO,GAAG,CAAC;;;;CAIrD,8BAA8B,EAAE,SAAS,EAAE,OAAO,GAAG,CAAC;;;;CAItD,sBAAsB,EAAE,SAAS,EAAE,OAAO,GAAG,CAAC;;;;CAK9C,YAAY,EAAE,SAAS,0BAA0B;;;;CAIjD,mBAAmB,EAAE,OAAO;;;;CAI5B,oBAAoB,EAAE,OAAO;;;;;CAK7B,qBAAqB,EAAE,SAAS,iBAAiB,CAAC;;;;CAIlD,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC,GAAG,EAAE,UAAU,aAAa,CAAC;;;;CAIrE,aAAa,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,CAAC,GAAG,EAAE,UAAU,aAAa,CAAC;;;;CAIvE,QAAQ,EAAE,KACN,EAAE,OAAO,GACT,EAAE,WACG,WACG,gBAAgB,cACZ,WACC,SACb,CACJ;AACJ,CAAC,GACD,EAAE,WACG,EACG,6BACA,8BACA,sBACA,GAAG,YACA;CACH,GAAG;CACH,6BAA6B,aAAa,2BAA2B;CACrE,8BAA8B,aAAa,4BAA4B;CACvE,sBAAsB,aAAa,oBAAoB;AAC3D,EACJ,CACJ;AAEA,MAAa,mBAAmB,EAAE,OAAO;CACrC,QAAQ,EAAE,MAAM,iBAAiB;CACjC,OAAO,EAAE,MAAM,gBAAgB;CAC/B,OAAO,EAAE,KACL,EAAE,OAAO,GACT,EAAE,WAAW,MAAM,OAAO,CAAC,IAAI,GAAI,CACvC;AACJ,CAAC"}

package/dist/services/orderbook/orderbook.schemas.d.ts

@@ -10,7 +10,7 @@ declare const GetOrderbookInputSchema: v.SchemaWithPipe<readonly [v.ObjectSchema
   depth: number;
 }, {
   symbolId: number;
-  depth: 1 | 10 | 5 | 20 | 200 | 500 | 1000 | 100 | 50;
+  depth: 1 | 10 | 5 | 20 | 200 | 500 | 100 | 1000 | 50;
   protoDepth: Depth;
 }>]>;
 type GetOrderbookInput = v.InferInput<typeof GetOrderbookInputSchema>;

package/dist/services/orders/orders-batch.schemas.d.ts

@@ -2903,6 +2903,7 @@ declare const BatchReplaceAdmissionItemSchema: v.SchemaWithPipe<readonly [v.Obje
   readonly status: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, "unspecified" | "rejected" | "admitted">]>;
   readonly oldOrderId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.BigintSchema<undefined>, undefined>, v.TransformAction<bigint | undefined, string | undefined>]>;
   readonly replacementOrderId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.BigintSchema<undefined>, undefined>, v.TransformAction<bigint | undefined, string | undefined>]>;
+  readonly actionTaken: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, "unspecified" | "AMENDED" | "REPLACED">]>;
   readonly clientOrderId: v.StringSchema<undefined>;
   readonly code: v.StringSchema<undefined>;
   readonly error: v.OptionalSchema<v.ObjectSchema<{
@@ -2929,6 +2930,7 @@ declare const BatchReplaceAdmissionItemSchema: v.SchemaWithPipe<readonly [v.Obje
   status: "unspecified" | "rejected" | "admitted";
   oldOrderId?: string | undefined;
   replacementOrderId?: string | undefined;
+  actionTaken: "unspecified" | "AMENDED" | "REPLACED";
   clientOrderId: string;
   code: string;
   error?: {
@@ -2956,6 +2958,7 @@ declare const BatchReplaceAdmissionItemSchema: v.SchemaWithPipe<readonly [v.Obje
   status: "unspecified" | "rejected" | "admitted";
   oldOrderId?: string | undefined;
   replacementOrderId?: string | undefined;
+  actionTaken: "unspecified" | "AMENDED" | "REPLACED";
   clientOrderId: string;
   error?: {
     code: "STALE_QUOTE" | "UNSPECIFIED" | "BAD_REQUEST" | "INVALID_ARGUMENT" | "INSUFFICIENT_FUNDS" | "UNKNOWN_SYMBOL" | "BAD_PRICE" | "BAD_QTY" | "MIN_NOTIONAL" | "QTY_STEP_SIZE" | "CONFLICT_DUPLICATE_CLIENT_ORDER_ID" | "UNAVAILABLE" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "UPSTREAM_ERROR" | "FEE_ASSET_NOT_ALLOWED" | "PAIR_DISABLED" | "ORDER_UNKNOWN" | "INTERNAL_ERROR" | "SUBACCOUNT_INACTIVE" | "POLICY_MARKET_DENY" | "POLICY_MAX_NOTIONAL" | "POLICY_TRADING_HALTED" | "POLICY_SPOT_TRADE_DENY" | "API_KEY_ROOT_SCOPE_ONLY" | "API_KEY_SUB_SCOPE_ONLY" | "API_KEY_SUBACCOUNT_MISMATCH" | "API_KEY_POLICY_REQUIRED" | "API_KEY_UNKNOWN" | "API_KEY_MARKET_DENY" | "PRICE_TICK_SIZE" | "MIN_QTY" | "POST_ONLY_LIMIT_ONLY" | "BATCH_TOO_LARGE" | "POLICY_MAX_OPEN_ORDERS" | "MODIFICATION_REQUIRES_REPLACE" | "CONFLICT_IDEMPOTENCY_KEY_REUSE" | "MARKET_PRICE_UNAVAILABLE" | "PAIR_NOT_LISTED_YET" | "PAIR_DELISTED" | "PAIR_CANCEL_ONLY" | "PAIR_POST_ONLY" | "PAIR_REDUCE_ONLY" | "RISK_LIMIT" | "MARKET_HALTED" | "ACCOUNT_UNKNOWN" | "POST_ONLY_CROSS" | "REDUCE_ONLY_BLOCKED" | "PRICE_BAND_VIOLATION" | "MARKET_CAP_VIOLATION" | "EMPTY_BOOK" | "FOK_INSUFFICIENT_LIQUIDITY" | "ORDER_ALREADY_TERMINAL" | "TRIGGER_PRICE_INVALID" | "TRIGGER_PRICE_SOURCE_UNSUPPORTED" | "TRAILING_DISTANCE_INVALID" | "TRIGGER_NOT_FOUND" | "TRIGGER_CANCEL_REJECTED" | "TRIGGER_STATUS_INVALID" | "TRIGGER_NOT_MODIFIABLE" | "CONFLICT_DUPLICATE_CLIENT_TRIGGER_ID" | "MAX_SLIPPAGE_INVALID" | "VALIDATION_ERROR" | "OVERLOADED" | "MAX_QUOTE_DEBIT_TOO_SMALL" | "RATE_LIMIT_EXCEEDED" | "SUBACCOUNT_READ_FORBIDDEN" | "POLICY_SPOT_READ_DENY" | "API_KEY_SPOT_READ_DENY" | "CANCEL_REQUEST_EXPIRED";
@@ -2986,6 +2989,7 @@ declare const BatchReplaceOrdersResultSchema: v.SchemaWithPipe<readonly [v.Objec
     readonly status: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, "unspecified" | "rejected" | "admitted">]>;
     readonly oldOrderId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.BigintSchema<undefined>, undefined>, v.TransformAction<bigint | undefined, string | undefined>]>;
     readonly replacementOrderId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.BigintSchema<undefined>, undefined>, v.TransformAction<bigint | undefined, string | undefined>]>;
+    readonly actionTaken: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, "unspecified" | "AMENDED" | "REPLACED">]>;
     readonly clientOrderId: v.StringSchema<undefined>;
     readonly code: v.StringSchema<undefined>;
     readonly error: v.OptionalSchema<v.ObjectSchema<{
@@ -3012,6 +3016,7 @@ declare const BatchReplaceOrdersResultSchema: v.SchemaWithPipe<readonly [v.Objec
     status: "unspecified" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     clientOrderId: string;
     code: string;
     error?: {
@@ -3039,6 +3044,7 @@ declare const BatchReplaceOrdersResultSchema: v.SchemaWithPipe<readonly [v.Objec
     status: "unspecified" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     clientOrderId: string;
     error?: {
       code: "STALE_QUOTE" | "UNSPECIFIED" | "BAD_REQUEST" | "INVALID_ARGUMENT" | "INSUFFICIENT_FUNDS" | "UNKNOWN_SYMBOL" | "BAD_PRICE" | "BAD_QTY" | "MIN_NOTIONAL" | "QTY_STEP_SIZE" | "CONFLICT_DUPLICATE_CLIENT_ORDER_ID" | "UNAVAILABLE" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "UPSTREAM_ERROR" | "FEE_ASSET_NOT_ALLOWED" | "PAIR_DISABLED" | "ORDER_UNKNOWN" | "INTERNAL_ERROR" | "SUBACCOUNT_INACTIVE" | "POLICY_MARKET_DENY" | "POLICY_MAX_NOTIONAL" | "POLICY_TRADING_HALTED" | "POLICY_SPOT_TRADE_DENY" | "API_KEY_ROOT_SCOPE_ONLY" | "API_KEY_SUB_SCOPE_ONLY" | "API_KEY_SUBACCOUNT_MISMATCH" | "API_KEY_POLICY_REQUIRED" | "API_KEY_UNKNOWN" | "API_KEY_MARKET_DENY" | "PRICE_TICK_SIZE" | "MIN_QTY" | "POST_ONLY_LIMIT_ONLY" | "BATCH_TOO_LARGE" | "POLICY_MAX_OPEN_ORDERS" | "MODIFICATION_REQUIRES_REPLACE" | "CONFLICT_IDEMPOTENCY_KEY_REUSE" | "MARKET_PRICE_UNAVAILABLE" | "PAIR_NOT_LISTED_YET" | "PAIR_DELISTED" | "PAIR_CANCEL_ONLY" | "PAIR_POST_ONLY" | "PAIR_REDUCE_ONLY" | "RISK_LIMIT" | "MARKET_HALTED" | "ACCOUNT_UNKNOWN" | "POST_ONLY_CROSS" | "REDUCE_ONLY_BLOCKED" | "PRICE_BAND_VIOLATION" | "MARKET_CAP_VIOLATION" | "EMPTY_BOOK" | "FOK_INSUFFICIENT_LIQUIDITY" | "ORDER_ALREADY_TERMINAL" | "TRIGGER_PRICE_INVALID" | "TRIGGER_PRICE_SOURCE_UNSUPPORTED" | "TRAILING_DISTANCE_INVALID" | "TRIGGER_NOT_FOUND" | "TRIGGER_CANCEL_REJECTED" | "TRIGGER_STATUS_INVALID" | "TRIGGER_NOT_MODIFIABLE" | "CONFLICT_DUPLICATE_CLIENT_TRIGGER_ID" | "MAX_SLIPPAGE_INVALID" | "VALIDATION_ERROR" | "OVERLOADED" | "MAX_QUOTE_DEBIT_TOO_SMALL" | "RATE_LIMIT_EXCEEDED" | "SUBACCOUNT_READ_FORBIDDEN" | "POLICY_SPOT_READ_DENY" | "API_KEY_SPOT_READ_DENY" | "CANCEL_REQUEST_EXPIRED";
@@ -3072,6 +3078,7 @@ declare const BatchReplaceOrdersResultSchema: v.SchemaWithPipe<readonly [v.Objec
     status: "unspecified" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     clientOrderId: string;
     error?: {
       code: "STALE_QUOTE" | "UNSPECIFIED" | "BAD_REQUEST" | "INVALID_ARGUMENT" | "INSUFFICIENT_FUNDS" | "UNKNOWN_SYMBOL" | "BAD_PRICE" | "BAD_QTY" | "MIN_NOTIONAL" | "QTY_STEP_SIZE" | "CONFLICT_DUPLICATE_CLIENT_ORDER_ID" | "UNAVAILABLE" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "UPSTREAM_ERROR" | "FEE_ASSET_NOT_ALLOWED" | "PAIR_DISABLED" | "ORDER_UNKNOWN" | "INTERNAL_ERROR" | "SUBACCOUNT_INACTIVE" | "POLICY_MARKET_DENY" | "POLICY_MAX_NOTIONAL" | "POLICY_TRADING_HALTED" | "POLICY_SPOT_TRADE_DENY" | "API_KEY_ROOT_SCOPE_ONLY" | "API_KEY_SUB_SCOPE_ONLY" | "API_KEY_SUBACCOUNT_MISMATCH" | "API_KEY_POLICY_REQUIRED" | "API_KEY_UNKNOWN" | "API_KEY_MARKET_DENY" | "PRICE_TICK_SIZE" | "MIN_QTY" | "POST_ONLY_LIMIT_ONLY" | "BATCH_TOO_LARGE" | "POLICY_MAX_OPEN_ORDERS" | "MODIFICATION_REQUIRES_REPLACE" | "CONFLICT_IDEMPOTENCY_KEY_REUSE" | "MARKET_PRICE_UNAVAILABLE" | "PAIR_NOT_LISTED_YET" | "PAIR_DELISTED" | "PAIR_CANCEL_ONLY" | "PAIR_POST_ONLY" | "PAIR_REDUCE_ONLY" | "RISK_LIMIT" | "MARKET_HALTED" | "ACCOUNT_UNKNOWN" | "POST_ONLY_CROSS" | "REDUCE_ONLY_BLOCKED" | "PRICE_BAND_VIOLATION" | "MARKET_CAP_VIOLATION" | "EMPTY_BOOK" | "FOK_INSUFFICIENT_LIQUIDITY" | "ORDER_ALREADY_TERMINAL" | "TRIGGER_PRICE_INVALID" | "TRIGGER_PRICE_SOURCE_UNSUPPORTED" | "TRAILING_DISTANCE_INVALID" | "TRIGGER_NOT_FOUND" | "TRIGGER_CANCEL_REJECTED" | "TRIGGER_STATUS_INVALID" | "TRIGGER_NOT_MODIFIABLE" | "CONFLICT_DUPLICATE_CLIENT_TRIGGER_ID" | "MAX_SLIPPAGE_INVALID" | "VALIDATION_ERROR" | "OVERLOADED" | "MAX_QUOTE_DEBIT_TOO_SMALL" | "RATE_LIMIT_EXCEEDED" | "SUBACCOUNT_READ_FORBIDDEN" | "POLICY_SPOT_READ_DENY" | "API_KEY_SPOT_READ_DENY" | "CANCEL_REQUEST_EXPIRED";
@@ -3105,6 +3112,7 @@ declare const BatchReplaceOrdersResultSchema: v.SchemaWithPipe<readonly [v.Objec
     status: "unspecified" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     clientOrderId: string;
     error?: {
       code: "STALE_QUOTE" | "UNSPECIFIED" | "BAD_REQUEST" | "INVALID_ARGUMENT" | "INSUFFICIENT_FUNDS" | "UNKNOWN_SYMBOL" | "BAD_PRICE" | "BAD_QTY" | "MIN_NOTIONAL" | "QTY_STEP_SIZE" | "CONFLICT_DUPLICATE_CLIENT_ORDER_ID" | "UNAVAILABLE" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "UPSTREAM_ERROR" | "FEE_ASSET_NOT_ALLOWED" | "PAIR_DISABLED" | "ORDER_UNKNOWN" | "INTERNAL_ERROR" | "SUBACCOUNT_INACTIVE" | "POLICY_MARKET_DENY" | "POLICY_MAX_NOTIONAL" | "POLICY_TRADING_HALTED" | "POLICY_SPOT_TRADE_DENY" | "API_KEY_ROOT_SCOPE_ONLY" | "API_KEY_SUB_SCOPE_ONLY" | "API_KEY_SUBACCOUNT_MISMATCH" | "API_KEY_POLICY_REQUIRED" | "API_KEY_UNKNOWN" | "API_KEY_MARKET_DENY" | "PRICE_TICK_SIZE" | "MIN_QTY" | "POST_ONLY_LIMIT_ONLY" | "BATCH_TOO_LARGE" | "POLICY_MAX_OPEN_ORDERS" | "MODIFICATION_REQUIRES_REPLACE" | "CONFLICT_IDEMPOTENCY_KEY_REUSE" | "MARKET_PRICE_UNAVAILABLE" | "PAIR_NOT_LISTED_YET" | "PAIR_DELISTED" | "PAIR_CANCEL_ONLY" | "PAIR_POST_ONLY" | "PAIR_REDUCE_ONLY" | "RISK_LIMIT" | "MARKET_HALTED" | "ACCOUNT_UNKNOWN" | "POST_ONLY_CROSS" | "REDUCE_ONLY_BLOCKED" | "PRICE_BAND_VIOLATION" | "MARKET_CAP_VIOLATION" | "EMPTY_BOOK" | "FOK_INSUFFICIENT_LIQUIDITY" | "ORDER_ALREADY_TERMINAL" | "TRIGGER_PRICE_INVALID" | "TRIGGER_PRICE_SOURCE_UNSUPPORTED" | "TRAILING_DISTANCE_INVALID" | "TRIGGER_NOT_FOUND" | "TRIGGER_CANCEL_REJECTED" | "TRIGGER_STATUS_INVALID" | "TRIGGER_NOT_MODIFIABLE" | "CONFLICT_DUPLICATE_CLIENT_TRIGGER_ID" | "MAX_SLIPPAGE_INVALID" | "VALIDATION_ERROR" | "OVERLOADED" | "MAX_QUOTE_DEBIT_TOO_SMALL" | "RATE_LIMIT_EXCEEDED" | "SUBACCOUNT_READ_FORBIDDEN" | "POLICY_SPOT_READ_DENY" | "API_KEY_SPOT_READ_DENY" | "CANCEL_REQUEST_EXPIRED";
@@ -3138,6 +3146,7 @@ declare const BatchReplaceOrdersResultSchema: v.SchemaWithPipe<readonly [v.Objec
     status: "unspecified" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     clientOrderId: string;
     error?: {
       code: "STALE_QUOTE" | "UNSPECIFIED" | "BAD_REQUEST" | "INVALID_ARGUMENT" | "INSUFFICIENT_FUNDS" | "UNKNOWN_SYMBOL" | "BAD_PRICE" | "BAD_QTY" | "MIN_NOTIONAL" | "QTY_STEP_SIZE" | "CONFLICT_DUPLICATE_CLIENT_ORDER_ID" | "UNAVAILABLE" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "UPSTREAM_ERROR" | "FEE_ASSET_NOT_ALLOWED" | "PAIR_DISABLED" | "ORDER_UNKNOWN" | "INTERNAL_ERROR" | "SUBACCOUNT_INACTIVE" | "POLICY_MARKET_DENY" | "POLICY_MAX_NOTIONAL" | "POLICY_TRADING_HALTED" | "POLICY_SPOT_TRADE_DENY" | "API_KEY_ROOT_SCOPE_ONLY" | "API_KEY_SUB_SCOPE_ONLY" | "API_KEY_SUBACCOUNT_MISMATCH" | "API_KEY_POLICY_REQUIRED" | "API_KEY_UNKNOWN" | "API_KEY_MARKET_DENY" | "PRICE_TICK_SIZE" | "MIN_QTY" | "POST_ONLY_LIMIT_ONLY" | "BATCH_TOO_LARGE" | "POLICY_MAX_OPEN_ORDERS" | "MODIFICATION_REQUIRES_REPLACE" | "CONFLICT_IDEMPOTENCY_KEY_REUSE" | "MARKET_PRICE_UNAVAILABLE" | "PAIR_NOT_LISTED_YET" | "PAIR_DELISTED" | "PAIR_CANCEL_ONLY" | "PAIR_POST_ONLY" | "PAIR_REDUCE_ONLY" | "RISK_LIMIT" | "MARKET_HALTED" | "ACCOUNT_UNKNOWN" | "POST_ONLY_CROSS" | "REDUCE_ONLY_BLOCKED" | "PRICE_BAND_VIOLATION" | "MARKET_CAP_VIOLATION" | "EMPTY_BOOK" | "FOK_INSUFFICIENT_LIQUIDITY" | "ORDER_ALREADY_TERMINAL" | "TRIGGER_PRICE_INVALID" | "TRIGGER_PRICE_SOURCE_UNSUPPORTED" | "TRAILING_DISTANCE_INVALID" | "TRIGGER_NOT_FOUND" | "TRIGGER_CANCEL_REJECTED" | "TRIGGER_STATUS_INVALID" | "TRIGGER_NOT_MODIFIABLE" | "CONFLICT_DUPLICATE_CLIENT_TRIGGER_ID" | "MAX_SLIPPAGE_INVALID" | "VALIDATION_ERROR" | "OVERLOADED" | "MAX_QUOTE_DEBIT_TOO_SMALL" | "RATE_LIMIT_EXCEEDED" | "SUBACCOUNT_READ_FORBIDDEN" | "POLICY_SPOT_READ_DENY" | "API_KEY_SPOT_READ_DENY" | "CANCEL_REQUEST_EXPIRED";
@@ -3173,6 +3182,7 @@ declare const BatchReplaceOrdersResultSchema: v.SchemaWithPipe<readonly [v.Objec
     status: "unspecified" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     clientOrderId: string;
     error?: {
       code: "STALE_QUOTE" | "UNSPECIFIED" | "BAD_REQUEST" | "INVALID_ARGUMENT" | "INSUFFICIENT_FUNDS" | "UNKNOWN_SYMBOL" | "BAD_PRICE" | "BAD_QTY" | "MIN_NOTIONAL" | "QTY_STEP_SIZE" | "CONFLICT_DUPLICATE_CLIENT_ORDER_ID" | "UNAVAILABLE" | "UNAUTHENTICATED" | "PERMISSION_DENIED" | "NOT_FOUND" | "UPSTREAM_ERROR" | "FEE_ASSET_NOT_ALLOWED" | "PAIR_DISABLED" | "ORDER_UNKNOWN" | "INTERNAL_ERROR" | "SUBACCOUNT_INACTIVE" | "POLICY_MARKET_DENY" | "POLICY_MAX_NOTIONAL" | "POLICY_TRADING_HALTED" | "POLICY_SPOT_TRADE_DENY" | "API_KEY_ROOT_SCOPE_ONLY" | "API_KEY_SUB_SCOPE_ONLY" | "API_KEY_SUBACCOUNT_MISMATCH" | "API_KEY_POLICY_REQUIRED" | "API_KEY_UNKNOWN" | "API_KEY_MARKET_DENY" | "PRICE_TICK_SIZE" | "MIN_QTY" | "POST_ONLY_LIMIT_ONLY" | "BATCH_TOO_LARGE" | "POLICY_MAX_OPEN_ORDERS" | "MODIFICATION_REQUIRES_REPLACE" | "CONFLICT_IDEMPOTENCY_KEY_REUSE" | "MARKET_PRICE_UNAVAILABLE" | "PAIR_NOT_LISTED_YET" | "PAIR_DELISTED" | "PAIR_CANCEL_ONLY" | "PAIR_POST_ONLY" | "PAIR_REDUCE_ONLY" | "RISK_LIMIT" | "MARKET_HALTED" | "ACCOUNT_UNKNOWN" | "POST_ONLY_CROSS" | "REDUCE_ONLY_BLOCKED" | "PRICE_BAND_VIOLATION" | "MARKET_CAP_VIOLATION" | "EMPTY_BOOK" | "FOK_INSUFFICIENT_LIQUIDITY" | "ORDER_ALREADY_TERMINAL" | "TRIGGER_PRICE_INVALID" | "TRIGGER_PRICE_SOURCE_UNSUPPORTED" | "TRAILING_DISTANCE_INVALID" | "TRIGGER_NOT_FOUND" | "TRIGGER_CANCEL_REJECTED" | "TRIGGER_STATUS_INVALID" | "TRIGGER_NOT_MODIFIABLE" | "CONFLICT_DUPLICATE_CLIENT_TRIGGER_ID" | "MAX_SLIPPAGE_INVALID" | "VALIDATION_ERROR" | "OVERLOADED" | "MAX_QUOTE_DEBIT_TOO_SMALL" | "RATE_LIMIT_EXCEEDED" | "SUBACCOUNT_READ_FORBIDDEN" | "POLICY_SPOT_READ_DENY" | "API_KEY_SPOT_READ_DENY" | "CANCEL_REQUEST_EXPIRED";
@@ -3221,6 +3231,7 @@ declare const GetBatchReplaceStatusResultSchema: v.SchemaWithPipe<readonly [v.Ob
     readonly phase: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, "unspecified" | "terminal" | "working" | "rejected" | "admitted">]>;
     readonly oldOrderId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.BigintSchema<undefined>, undefined>, v.TransformAction<bigint | undefined, string | undefined>]>;
     readonly replacementOrderId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.BigintSchema<undefined>, undefined>, v.TransformAction<bigint | undefined, string | undefined>]>;
+    readonly actionTaken: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, "unspecified" | "AMENDED" | "REPLACED">]>;
     readonly orderStatus: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, "unspecified" | "pending" | "pending_cancel" | "working" | "filled" | "canceled" | "rejected">]>;
     readonly code: v.StringSchema<undefined>;
     readonly updatedTsNs: v.BigintSchema<undefined>;
@@ -3229,6 +3240,7 @@ declare const GetBatchReplaceStatusResultSchema: v.SchemaWithPipe<readonly [v.Ob
     phase: "unspecified" | "terminal" | "working" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     orderStatus: "unspecified" | "pending" | "pending_cancel" | "working" | "filled" | "canceled" | "rejected";
     code: string;
     updatedTsNs: bigint;
@@ -3240,6 +3252,7 @@ declare const GetBatchReplaceStatusResultSchema: v.SchemaWithPipe<readonly [v.Ob
     phase: "unspecified" | "terminal" | "working" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     orderStatus: "unspecified" | "pending" | "pending_cancel" | "working" | "filled" | "canceled" | "rejected";
   }>]>, undefined>;
   readonly acceptedCount: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
@@ -3257,6 +3270,7 @@ declare const GetBatchReplaceStatusResultSchema: v.SchemaWithPipe<readonly [v.Ob
     phase: "unspecified" | "terminal" | "working" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     orderStatus: "unspecified" | "pending" | "pending_cancel" | "working" | "filled" | "canceled" | "rejected";
   }[];
   acceptedCount: number;
@@ -3274,6 +3288,7 @@ declare const GetBatchReplaceStatusResultSchema: v.SchemaWithPipe<readonly [v.Ob
     phase: "unspecified" | "terminal" | "working" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     orderStatus: "unspecified" | "pending" | "pending_cancel" | "working" | "filled" | "canceled" | "rejected";
   }[];
   acceptedCount: number;
@@ -3291,6 +3306,7 @@ declare const GetBatchReplaceStatusResultSchema: v.SchemaWithPipe<readonly [v.Ob
     phase: "unspecified" | "terminal" | "working" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     orderStatus: "unspecified" | "pending" | "pending_cancel" | "working" | "filled" | "canceled" | "rejected";
   }[];
   acceptedCount: number;
@@ -3312,6 +3328,7 @@ declare const GetBatchReplaceStatusResultSchema: v.SchemaWithPipe<readonly [v.Ob
     phase: "unspecified" | "terminal" | "working" | "rejected" | "admitted";
     oldOrderId?: string | undefined;
     replacementOrderId?: string | undefined;
+    actionTaken: "unspecified" | "AMENDED" | "REPLACED";
     orderStatus: "unspecified" | "pending" | "pending_cancel" | "working" | "filled" | "canceled" | "rejected";
   }[];
   acceptedCount: number;

package/dist/services/orders/orders-batch.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orders-batch.schemas.d.ts","names":[],"sources":["../../../src/services/orders/orders-batch.schemas.ts"],"mappings":";;;;;;cAwDa,2BAAyB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;KAc1B,sBAAsB,EAAE,kBAAkB;cAEzC,4BAA0B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;KAgB3B,uBAAuB,EAAE,mBAAmB;iBAExC,mCAAmC,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwBxD,yBAAyB,EAAE,WACnC,kBAAkB;iBA4BN,oCAAoC,QAAQ,WAAW,sBAAmB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsD9E,0BAA0B,EAAE,YACpC,kBAAkB;KAEV,yBAAyB;KAkIzB;EACR,UAAU,EAAE,kBAAkB,yBAAyB;EACvD;EACA;EACA,OAAO;IACH;IACA;IACA;IACA;IACA,OAAO,EAAE,WAAW,kBAAkB;IACtC;IACA;;;cAIF,iCAA+B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgBzB,4BAA4B,EAAE,mBAAmB;cAEhD,gCAA8B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwB/B,2BAA2B,EAAE,mBAAmB;cAE/C,kCAAgC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;KAcjC,6BAA6B,EAAE,kBAAkB;cAoBhD,mCAAiC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2BlC,8BAA8B,EAAE,mBAAmB;cAEzD,6BAA2B,EAAA,aAAA,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;KAmBrB,wBAAwB,EAAE,kBAAkB;cAE3C,8BAA4B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgB7B,yBAAyB,EAAE,kBAAkB;cAEnD,8BAA4B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAQtB,yBAAyB,EAAE,mBAAmB;cAE7C,+BAA6B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkB9B,0BAA0B,EAAE,mBAAmB"}
+{"version":3,"file":"orders-batch.schemas.d.ts","names":[],"sources":["../../../src/services/orders/orders-batch.schemas.ts"],"mappings":";;;;;;cAyDa,2BAAyB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;KAc1B,sBAAsB,EAAE,kBAAkB;cAEzC,4BAA0B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;KAgB3B,uBAAuB,EAAE,mBAAmB;iBAExC,mCAAmC,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwBxD,yBAAyB,EAAE,WACnC,kBAAkB;iBA4BN,oCAAoC,QAAQ,WAAW,sBAAmB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsD9E,0BAA0B,EAAE,YACpC,kBAAkB;KAEV,yBAAyB;KAkIzB;EACR,UAAU,EAAE,kBAAkB,yBAAyB;EACvD;EACA;EACA,OAAO;IACH;IACA;IACA;IACA;IACA,OAAO,EAAE,WAAW,kBAAkB;IACtC;IACA;;;cAIF,iCAA+B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiBzB,4BAA4B,EAAE,mBAAmB;cAEhD,gCAA8B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwB/B,2BAA2B,EAAE,mBAAmB;cAE/C,kCAAgC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;KAcjC,6BAA6B,EAAE,kBAAkB;cAqBhD,mCAAiC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2BlC,8BAA8B,EAAE,mBAAmB;cAEzD,6BAA2B,EAAA,aAAA,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;KAmBrB,wBAAwB,EAAE,kBAAkB;cAE3C,8BAA4B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgB7B,yBAAyB,EAAE,kBAAkB;cAEnD,8BAA4B,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAQtB,yBAAyB,EAAE,mBAAmB;cAE7C,+BAA6B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkB9B,0BAA0B,EAAE,mBAAmB"}

package/dist/services/orders/orders-batch.schemas.js

@@ -8,7 +8,7 @@ import { SideSchema, SymbolIdInputSchema } from "../shared.js";
 import { AccountScopeInputEntries, accountScopeToSubaccountId } from "../../shared/account-scope.js";
 import { positiveDecimalInputToScaled, scaledToDecimalOutput } from "../../shared/decimal-surface.js";
 import { OrderSideCodec } from "./order-enums.codecs.js";
-import { BatchCancelOrderStatusCodec, BatchReplaceAdmissionStatusCodec, BatchReplaceItemAdmissionStatusCodec, BatchReplacePhaseCodec, CancelAllAfterStatusCodec, OrderStatusCodec } from "./orders.codecs.js";
+import { BatchCancelOrderStatusCodec, BatchReplaceAdmissionStatusCodec, BatchReplaceItemAdmissionStatusCodec, BatchReplacePhaseCodec, CancelAllAfterStatusCodec, ModifyActionCodec, OrderStatusCodec } from "./orders.codecs.js";
 import { ClientOrderIdInputSchema, OrderRequestIdInputSchema, positiveOrderIdInputSchema } from "./orders-identifiers.schemas.js";
 import { createRequiredRiskPolicyInputSchema } from "./orders-risk.schemas.js";
 import { createOrderIntentInputSchema } from "./orders-input.schemas.js";
@@ -187,6 +187,7 @@ const BatchReplaceAdmissionItemSchema = v.pipe(v.object({
 	status: enumLabelSchema(BatchReplaceItemAdmissionStatusCodec.protoToOutput),
 	oldOrderId: OptionalPublicIdSchema,
 	replacementOrderId: OptionalPublicIdSchema,
+	actionTaken: enumLabelSchema(ModifyActionCodec.protoToOutput),
 	clientOrderId: v.string(),
 	code: v.string(),
 	error: v.optional(OrderErrorDetailSchema)
@@ -218,6 +219,7 @@ const BatchReplaceStatusItemSchema = v.pipe(v.object({
 	phase: enumLabelSchema(BatchReplacePhaseCodec.protoToOutput),
 	oldOrderId: OptionalPublicIdSchema,
 	replacementOrderId: OptionalPublicIdSchema,
+	actionTaken: enumLabelSchema(ModifyActionCodec.protoToOutput),
 	orderStatus: enumLabelSchema(OrderStatusCodec.protoToOutput),
 	code: v.string(),
 	updatedTsNs: v.bigint()

package/dist/services/orders/orders-batch.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"orders-batch.schemas.js","names":["ProtoWrite.RiskPolicySchema"],"sources":["../../../src/services/orders/orders-batch.schemas.ts"],"sourcesContent":["import * as ProtoWrite from \"../../gen/orders/v1/orders_pb.js\";\nimport { create } from \"@bufbuild/protobuf\";\nimport * as v from \"valibot\";\nimport {\n    AccountScopeInputEntries,\n    accountScopeToSubaccountId,\n} from \"../../shared/account-scope.js\";\nimport { OptionalPublicIdSchema, PublicIdSchema, idInputSchema } from \"../../shared/schemas.js\";\nimport { enumLabelSchema } from \"../../shared/proto-enum-codec.js\";\nimport { tsNsToMs } from \"../../utils/time.js\";\nimport { formatId } from \"../../utils/base58-id.js\";\nimport { SideSchema, SymbolIdInputSchema } from \"../shared.js\";\nimport {\n    positiveDecimalInputToScaled,\n    scaledToDecimalOutput,\n    type SdkScales,\n} from \"../../shared/decimal-surface.js\";\nimport {\n    BatchReplaceAdmissionStatusCodec,\n    BatchCancelOrderStatusCodec,\n    CancelAllAfterStatusCodec,\n    BatchReplaceItemAdmissionStatusCodec,\n    BatchReplacePhaseCodec,\n    OrderStatusCodec,\n    OrderSideCodec,\n} from \"./orders.codecs.js\";\nimport { createOrderIntentInputSchema } from \"./orders-input.schemas.js\";\nimport { createRequiredRiskPolicyInputSchema } from \"./orders-risk.schemas.js\";\nimport {\n    ClientOrderIdInputSchema,\n    positiveOrderIdInputSchema,\n    OrderRequestIdInputSchema,\n} from \"./orders-identifiers.schemas.js\";\nimport { OrderErrorDetailSchema } from \"./order-errors.schemas.js\";\n\nconst BatchCountSchema = v.pipe(v.number(), v.integer(), v.minValue(0));\nconst BatchItemIndexSchema = v.pipe(v.number(), v.integer(), v.minValue(0));\nconst PositivePublicIdSchema = v.pipe(\n    v.bigint(),\n    v.gtValue(0n),\n    v.transform((value) => formatId(value)),\n);\nconst OptionalSideInputSchema = v.pipe(\n    v.optional(SideSchema),\n    v.transform((side) => (side ? OrderSideCodec.inputToProto[side] : undefined)),\n);\n\nconst CancelAllAfterTimeoutInputSchema = v.pipe(\n    v.number(),\n    v.integer(),\n    v.check(\n        (timeoutSec) => timeoutSec === 0 || (timeoutSec >= 10 && timeoutSec <= 120),\n        \"timeoutSec must be 0 to disable or between 10 and 120 seconds to arm\",\n    ),\n);\n\nexport const CancelAllAfterInputSchema = v.pipe(\n    v.strictObject({\n        ...AccountScopeInputEntries,\n        timeoutSec: CancelAllAfterTimeoutInputSchema,\n        symbolId: v.optional(SymbolIdInputSchema),\n        side: OptionalSideInputSchema,\n        requestId: v.optional(OrderRequestIdInputSchema),\n    }),\n    v.transform(({ account, ...input }) => ({\n        ...input,\n        subaccountId: accountScopeToSubaccountId(account),\n    })),\n);\n\nexport type CancelAllAfterInput = v.InferInput<typeof CancelAllAfterInputSchema>;\n\nexport const CancelAllAfterResultSchema = v.pipe(\n    v.object({\n        status: enumLabelSchema(CancelAllAfterStatusCodec.protoToOutput),\n        effectiveTimeoutSec: v.pipe(v.number(), v.integer(), v.minValue(0)),\n        expiresAtTsNs: v.bigint(),\n        tsNs: v.bigint(),\n    }),\n    v.transform(({ expiresAtTsNs, tsNs, ...result }) => ({\n        ...result,\n        expiresAt: tsNsToMs(expiresAtTsNs),\n        expiresAtNs: expiresAtTsNs.toString(),\n        ts: tsNsToMs(tsNs),\n        tsNs: tsNs.toString(),\n    })),\n);\n\nexport type CancelAllAfterResult = v.InferOutput<typeof CancelAllAfterResultSchema>;\n\nexport function createBatchCreateOrdersInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.strictObject({\n            ...AccountScopeInputEntries,\n            requestId: v.optional(OrderRequestIdInputSchema),\n            items: v.pipe(\n                v.array(createOrderIntentInputSchema(scales)),\n                v.minLength(1, \"At least one order is required.\"),\n                v.maxLength(20, \"Batch create accepts at most 20 orders.\"),\n            ),\n        }),\n        v.check((input) => {\n            const clientOrderIds = input.items\n                .map((item) => item.clientOrderId)\n                .filter((clientOrderId) => clientOrderId !== undefined && clientOrderId !== \"\");\n            return new Set(clientOrderIds).size === clientOrderIds.length;\n        }, \"Each non-empty batch create clientOrderId must be unique.\"),\n        v.transform(({ account, ...input }) => ({\n            ...input,\n            subaccountId: accountScopeToSubaccountId(account),\n        })),\n    );\n}\n\nexport type BatchCreateOrdersInput = v.InferInput<\n    ReturnType<typeof createBatchCreateOrdersInputSchema>\n>;\n\nconst BatchCreateOrderResultRawSchema = v.object({\n    clientOrderId: v.string(),\n    outcome: v.variant(\"case\", [\n        v.object({\n            case: v.literal(\"accepted\"),\n            value: v.object({\n                orderId: PublicIdSchema,\n                takeProfitTriggerId: OptionalPublicIdSchema,\n                stopLossTriggerId: OptionalPublicIdSchema,\n                trailingStopTriggerId: OptionalPublicIdSchema,\n                resolvedBaseQtyScaled: v.bigint(),\n                submittedMaxQuoteDebitScaled: v.optional(v.bigint()),\n            }),\n        }),\n        v.object({\n            case: v.literal(\"rejected\"),\n            value: v.object({\n                // The server may reject without a structured detail (e.g. capacity\n                // limits); surface the rejection instead of failing the parse.\n                error: v.optional(OrderErrorDetailSchema),\n            }),\n        }),\n    ]),\n});\n\nexport function createBatchCreateOrdersResultSchema(scales: SdkScales, symbolIds: number[]) {\n    return v.pipe(\n        v.object({\n            results: v.array(BatchCreateOrderResultRawSchema),\n            acceptedCount: BatchCountSchema,\n            rejectedCount: BatchCountSchema,\n            tsNs: v.bigint(),\n        }),\n        v.check(\n            (response) =>\n                response.acceptedCount + response.rejectedCount === response.results.length,\n            \"Batch create result counts do not match the returned results.\",\n        ),\n        v.check(\n            (response) => response.results.length === symbolIds.length,\n            \"Batch create result count does not match the submitted item count.\",\n        ),\n        v.transform(({ tsNs, ...response }) => ({\n            ...response,\n            results: response.results.map(({ clientOrderId, outcome }, index) => {\n                if (outcome.case === \"rejected\") {\n                    return {\n                        status: \"rejected\" as const,\n                        clientOrderId,\n                        error: outcome.value.error,\n                    };\n                }\n                const { resolvedBaseQtyScaled, submittedMaxQuoteDebitScaled, ...accepted } =\n                    outcome.value;\n                const symbolId = symbolIds[index]!;\n                return {\n                    status: \"accepted\" as const,\n                    clientOrderId,\n                    ...accepted,\n                    resolvedBaseQty: scaledToDecimalOutput(\n                        resolvedBaseQtyScaled,\n                        scales.baseQty(symbolId),\n                    ),\n                    ...(submittedMaxQuoteDebitScaled === undefined\n                        ? {}\n                        : {\n                              submittedMaxQuoteDebit: scaledToDecimalOutput(\n                                  submittedMaxQuoteDebitScaled,\n                                  scales.quoteAmount(symbolId),\n                              ),\n                          }),\n                };\n            }),\n            ts: tsNsToMs(tsNs),\n            tsNs: tsNs.toString(),\n        })),\n    );\n}\n\nexport type BatchCreateOrdersResult = v.InferOutput<\n    ReturnType<typeof createBatchCreateOrdersResultSchema>\n>;\nexport type BatchCreateOrderResult = BatchCreateOrdersResult[\"results\"][number];\n\nconst DecimalInputStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));\nconst BATCH_REPLACE_ITEM_INPUT_KEYS = new Set([\n    \"orderId\",\n    \"clientOrderId\",\n    \"newPrice\",\n    \"newQty\",\n    \"risk\",\n    \"clearRisk\",\n    \"newClientOrderId\",\n]);\n\nexport function assertKnownBatchReplaceOrderItemInputKeys(input: object): void {\n    for (const key of Object.keys(input)) {\n        if (!BATCH_REPLACE_ITEM_INPUT_KEYS.has(key)) {\n            throw new Error(`Unknown key \"${key}\" in batch replace order item.`);\n        }\n    }\n}\n\nconst BatchReplaceTargetInputSchema = v.union([\n    v.pipe(\n        v.object({\n            orderId: v.pipe(\n                idInputSchema(\"items.orderId\"),\n                v.check((value) => value > 0n, \"items.orderId must be greater than zero\"),\n            ),\n            clientOrderId: v.optional(v.never()),\n        }),\n        v.transform(({ orderId }) => ({\n            key: { case: \"orderId\" as const, value: orderId },\n        })),\n    ),\n    v.pipe(\n        v.object({\n            orderId: v.optional(v.never()),\n            clientOrderId: ClientOrderIdInputSchema,\n        }),\n        v.transform(({ clientOrderId }) => ({\n            key: { case: \"clientOrderId\" as const, value: clientOrderId },\n        })),\n    ),\n]);\n\nfunction createBatchReplaceOrderItemInputSchema(scales: SdkScales) {\n    const patchSchema = v.union([\n        v.object({\n            newPrice: DecimalInputStringSchema,\n            newQty: v.optional(DecimalInputStringSchema),\n            risk: v.optional(createRequiredRiskPolicyInputSchema(scales)),\n            clearRisk: v.optional(v.literal(false)),\n        }),\n        v.object({\n            newPrice: v.optional(DecimalInputStringSchema),\n            newQty: DecimalInputStringSchema,\n            risk: v.optional(createRequiredRiskPolicyInputSchema(scales)),\n            clearRisk: v.optional(v.literal(false)),\n        }),\n        v.object({\n            newPrice: v.optional(v.never()),\n            newQty: v.optional(v.never()),\n            risk: createRequiredRiskPolicyInputSchema(scales),\n            clearRisk: v.optional(v.literal(false)),\n        }),\n        v.object({\n            newPrice: v.optional(v.never()),\n            newQty: v.optional(v.never()),\n            risk: v.optional(v.never()),\n            clearRisk: v.literal(true),\n        }),\n    ]);\n    return v.intersect([\n        BatchReplaceTargetInputSchema,\n        patchSchema,\n        v.object({\n            newClientOrderId: v.optional(ClientOrderIdInputSchema),\n        }),\n    ]);\n}\n\nexport function createBatchReplaceOrdersInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.strictObject({\n            ...AccountScopeInputEntries,\n            symbolId: SymbolIdInputSchema,\n            requestId: v.optional(OrderRequestIdInputSchema),\n            items: v.pipe(\n                v.array(createBatchReplaceOrderItemInputSchema(scales)),\n                v.minLength(1, \"At least one replacement is required.\"),\n                v.maxLength(50, \"Batch replace accepts at most 50 replacements.\"),\n            ),\n        }),\n        v.check((input) => {\n            const targets = input.items.map(\n                (item) => `${item.key.case}:${item.key.value.toString()}`,\n            );\n            return new Set(targets).size === targets.length;\n        }, \"Each batch replace target must be unique.\"),\n        v.transform(({ account, items, ...input }) => {\n            return {\n                ...input,\n                items: items.map((item) => ({\n                    key: item.key,\n                    newPriceTicks:\n                        item.newPrice === undefined\n                            ? undefined\n                            : positiveDecimalInputToScaled(\n                                  \"items.newPrice\",\n                                  item.newPrice,\n                                  scales.price(),\n                              ),\n                    newQtyScaled:\n                        item.newQty === undefined\n                            ? undefined\n                            : positiveDecimalInputToScaled(\n                                  \"items.newQty\",\n                                  item.newQty,\n                                  scales.baseQty(input.symbolId),\n                              ),\n                    newAttachedRisk:\n                        item.clearRisk === true ? create(ProtoWrite.RiskPolicySchema) : item.risk,\n                    newClientOrderId: item.newClientOrderId ?? \"\",\n                })),\n                subaccountId: accountScopeToSubaccountId(account),\n            };\n        }),\n    );\n}\n\nexport type BatchReplaceOrdersInput = {\n    account?: v.InferInput<typeof AccountScopeInputEntries.account>;\n    symbolId: number;\n    requestId?: string;\n    items: Array<{\n        orderId?: string;\n        clientOrderId?: string;\n        newPrice?: string;\n        newQty?: string;\n        risk?: v.InferInput<ReturnType<typeof createRequiredRiskPolicyInputSchema>>;\n        clearRisk?: boolean;\n        newClientOrderId?: string;\n    }>;\n};\n\nconst BatchReplaceAdmissionItemSchema = v.pipe(\n    v.object({\n        itemIndex: BatchItemIndexSchema,\n        status: enumLabelSchema(BatchReplaceItemAdmissionStatusCodec.protoToOutput),\n        oldOrderId: OptionalPublicIdSchema,\n        replacementOrderId: OptionalPublicIdSchema,\n        clientOrderId: v.string(),\n        code: v.string(),\n        error: v.optional(OrderErrorDetailSchema),\n    }),\n    v.transform((item) => ({\n        ...item,\n        code: item.code || undefined,\n    })),\n);\n\nexport type BatchReplaceAdmissionItem = v.InferOutput<typeof BatchReplaceAdmissionItemSchema>;\n\nexport const BatchReplaceOrdersResultSchema = v.pipe(\n    v.object({\n        batchRequestId: PositivePublicIdSchema,\n        status: enumLabelSchema(BatchReplaceAdmissionStatusCodec.protoToOutput),\n        results: v.array(BatchReplaceAdmissionItemSchema),\n        acceptedCount: BatchCountSchema,\n        rejectedCount: BatchCountSchema,\n        acceptedTsNs: v.bigint(),\n    }),\n    v.check(\n        (response) => response.acceptedCount + response.rejectedCount === response.results.length,\n        \"Batch replace result counts do not match the returned results.\",\n    ),\n    v.check(\n        (response) => response.results.every((item, index) => item.itemIndex === index),\n        \"Batch replace results must preserve request item order.\",\n    ),\n    v.transform(({ acceptedTsNs, ...response }) => ({\n        ...response,\n        acceptedTs: tsNsToMs(acceptedTsNs),\n        acceptedTsNs: acceptedTsNs.toString(),\n    })),\n);\n\nexport type BatchReplaceOrdersResult = v.InferOutput<typeof BatchReplaceOrdersResultSchema>;\n\nexport const GetBatchReplaceStatusInputSchema = v.pipe(\n    v.strictObject({\n        ...AccountScopeInputEntries,\n        batchRequestId: v.pipe(\n            idInputSchema(\"batchRequestId\"),\n            v.check((value) => value > 0n, \"batchRequestId must be greater than zero\"),\n        ),\n    }),\n    v.transform(({ account, ...input }) => ({\n        ...input,\n        subaccountId: accountScopeToSubaccountId(account),\n    })),\n);\n\nexport type GetBatchReplaceStatusInput = v.InferInput<typeof GetBatchReplaceStatusInputSchema>;\n\nconst BatchReplaceStatusItemSchema = v.pipe(\n    v.object({\n        itemIndex: BatchItemIndexSchema,\n        phase: enumLabelSchema(BatchReplacePhaseCodec.protoToOutput),\n        oldOrderId: OptionalPublicIdSchema,\n        replacementOrderId: OptionalPublicIdSchema,\n        orderStatus: enumLabelSchema(OrderStatusCodec.protoToOutput),\n        code: v.string(),\n        updatedTsNs: v.bigint(),\n    }),\n    v.transform(({ updatedTsNs, ...item }) => ({\n        ...item,\n        code: item.code || undefined,\n        updatedTs: tsNsToMs(updatedTsNs),\n        updatedTsNs: updatedTsNs.toString(),\n    })),\n);\n\nexport const GetBatchReplaceStatusResultSchema = v.pipe(\n    v.object({\n        batchRequestId: PositivePublicIdSchema,\n        admissionStatus: enumLabelSchema(BatchReplaceAdmissionStatusCodec.protoToOutput),\n        items: v.array(BatchReplaceStatusItemSchema),\n        acceptedCount: BatchCountSchema,\n        rejectedCount: BatchCountSchema,\n        acceptedTsNs: v.bigint(),\n        updatedTsNs: v.bigint(),\n    }),\n    v.check(\n        (response) => response.acceptedCount + response.rejectedCount === response.items.length,\n        \"Batch replace status counts do not match the returned items.\",\n    ),\n    v.check(\n        (response) => response.items.every((item, index) => item.itemIndex === index),\n        \"Batch replace status items must preserve request item order.\",\n    ),\n    v.transform(({ acceptedTsNs, updatedTsNs, ...response }) => ({\n        ...response,\n        acceptedTs: tsNsToMs(acceptedTsNs),\n        acceptedTsNs: acceptedTsNs.toString(),\n        updatedTs: tsNsToMs(updatedTsNs),\n        updatedTsNs: updatedTsNs.toString(),\n    })),\n);\n\nexport type GetBatchReplaceStatusResult = v.InferOutput<typeof GetBatchReplaceStatusResultSchema>;\n\nconst BatchCancelOrderInputSchema = v.union([\n    v.pipe(\n        v.strictObject({\n            orderId: positiveOrderIdInputSchema(\"items.orderId\"),\n            clientOrderId: v.optional(v.never()),\n            symbolId: v.optional(SymbolIdInputSchema),\n        }),\n        v.transform(({ orderId, symbolId }) => ({ orderId, symbolId })),\n    ),\n    v.pipe(\n        v.strictObject({\n            orderId: v.optional(v.never()),\n            clientOrderId: ClientOrderIdInputSchema,\n            symbolId: v.optional(SymbolIdInputSchema),\n        }),\n        v.transform(({ clientOrderId, symbolId }) => ({ clientOrderId, symbolId })),\n    ),\n]);\n\nexport type BatchCancelOrderInput = v.InferInput<typeof BatchCancelOrderInputSchema>;\n\nexport const BatchCancelOrdersInputSchema = v.pipe(\n    v.strictObject({\n        ...AccountScopeInputEntries,\n        requestId: v.optional(OrderRequestIdInputSchema),\n        items: v.pipe(\n            v.array(BatchCancelOrderInputSchema),\n            v.minLength(1, \"At least one order is required.\"),\n            v.maxLength(50, \"Batch cancel accepts at most 50 orders.\"),\n        ),\n    }),\n    v.transform(({ account, ...input }) => ({\n        ...input,\n        subaccountId: accountScopeToSubaccountId(account),\n    })),\n);\n\nexport type BatchCancelOrdersInput = v.InferInput<typeof BatchCancelOrdersInputSchema>;\n\nconst BatchCancelOrderResultSchema = v.object({\n    status: enumLabelSchema(BatchCancelOrderStatusCodec.protoToOutput),\n    orderId: OptionalPublicIdSchema,\n    clientOrderId: v.string(),\n    code: v.string(),\n    error: v.optional(OrderErrorDetailSchema),\n});\n\nexport type BatchCancelOrderResult = v.InferOutput<typeof BatchCancelOrderResultSchema>;\n\nexport const BatchCancelOrdersResultSchema = v.pipe(\n    v.object({\n        results: v.array(BatchCancelOrderResultSchema),\n        acceptedCount: BatchCountSchema,\n        rejectedCount: BatchCountSchema,\n        tsNs: v.bigint(),\n    }),\n    v.check(\n        (response) => response.acceptedCount + response.rejectedCount === response.results.length,\n        \"Batch cancel result counts do not match the returned results.\",\n    ),\n    v.transform(({ tsNs, ...response }) => ({\n        ...response,\n        ts: tsNsToMs(tsNs),\n        tsNs: tsNs.toString(),\n    })),\n);\n\nexport type BatchCancelOrdersResult = v.InferOutput<typeof BatchCancelOrdersResultSchema>;\n"],"mappings":"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"}
+{"version":3,"file":"orders-batch.schemas.js","names":["ProtoWrite.RiskPolicySchema"],"sources":["../../../src/services/orders/orders-batch.schemas.ts"],"sourcesContent":["import * as ProtoWrite from \"../../gen/orders/v1/orders_pb.js\";\nimport { create } from \"@bufbuild/protobuf\";\nimport * as v from \"valibot\";\nimport {\n    AccountScopeInputEntries,\n    accountScopeToSubaccountId,\n} from \"../../shared/account-scope.js\";\nimport { OptionalPublicIdSchema, PublicIdSchema, idInputSchema } from \"../../shared/schemas.js\";\nimport { enumLabelSchema } from \"../../shared/proto-enum-codec.js\";\nimport { tsNsToMs } from \"../../utils/time.js\";\nimport { formatId } from \"../../utils/base58-id.js\";\nimport { SideSchema, SymbolIdInputSchema } from \"../shared.js\";\nimport {\n    positiveDecimalInputToScaled,\n    scaledToDecimalOutput,\n    type SdkScales,\n} from \"../../shared/decimal-surface.js\";\nimport {\n    BatchReplaceAdmissionStatusCodec,\n    BatchCancelOrderStatusCodec,\n    CancelAllAfterStatusCodec,\n    BatchReplaceItemAdmissionStatusCodec,\n    BatchReplacePhaseCodec,\n    ModifyActionCodec,\n    OrderStatusCodec,\n    OrderSideCodec,\n} from \"./orders.codecs.js\";\nimport { createOrderIntentInputSchema } from \"./orders-input.schemas.js\";\nimport { createRequiredRiskPolicyInputSchema } from \"./orders-risk.schemas.js\";\nimport {\n    ClientOrderIdInputSchema,\n    positiveOrderIdInputSchema,\n    OrderRequestIdInputSchema,\n} from \"./orders-identifiers.schemas.js\";\nimport { OrderErrorDetailSchema } from \"./order-errors.schemas.js\";\n\nconst BatchCountSchema = v.pipe(v.number(), v.integer(), v.minValue(0));\nconst BatchItemIndexSchema = v.pipe(v.number(), v.integer(), v.minValue(0));\nconst PositivePublicIdSchema = v.pipe(\n    v.bigint(),\n    v.gtValue(0n),\n    v.transform((value) => formatId(value)),\n);\nconst OptionalSideInputSchema = v.pipe(\n    v.optional(SideSchema),\n    v.transform((side) => (side ? OrderSideCodec.inputToProto[side] : undefined)),\n);\n\nconst CancelAllAfterTimeoutInputSchema = v.pipe(\n    v.number(),\n    v.integer(),\n    v.check(\n        (timeoutSec) => timeoutSec === 0 || (timeoutSec >= 10 && timeoutSec <= 120),\n        \"timeoutSec must be 0 to disable or between 10 and 120 seconds to arm\",\n    ),\n);\n\nexport const CancelAllAfterInputSchema = v.pipe(\n    v.strictObject({\n        ...AccountScopeInputEntries,\n        timeoutSec: CancelAllAfterTimeoutInputSchema,\n        symbolId: v.optional(SymbolIdInputSchema),\n        side: OptionalSideInputSchema,\n        requestId: v.optional(OrderRequestIdInputSchema),\n    }),\n    v.transform(({ account, ...input }) => ({\n        ...input,\n        subaccountId: accountScopeToSubaccountId(account),\n    })),\n);\n\nexport type CancelAllAfterInput = v.InferInput<typeof CancelAllAfterInputSchema>;\n\nexport const CancelAllAfterResultSchema = v.pipe(\n    v.object({\n        status: enumLabelSchema(CancelAllAfterStatusCodec.protoToOutput),\n        effectiveTimeoutSec: v.pipe(v.number(), v.integer(), v.minValue(0)),\n        expiresAtTsNs: v.bigint(),\n        tsNs: v.bigint(),\n    }),\n    v.transform(({ expiresAtTsNs, tsNs, ...result }) => ({\n        ...result,\n        expiresAt: tsNsToMs(expiresAtTsNs),\n        expiresAtNs: expiresAtTsNs.toString(),\n        ts: tsNsToMs(tsNs),\n        tsNs: tsNs.toString(),\n    })),\n);\n\nexport type CancelAllAfterResult = v.InferOutput<typeof CancelAllAfterResultSchema>;\n\nexport function createBatchCreateOrdersInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.strictObject({\n            ...AccountScopeInputEntries,\n            requestId: v.optional(OrderRequestIdInputSchema),\n            items: v.pipe(\n                v.array(createOrderIntentInputSchema(scales)),\n                v.minLength(1, \"At least one order is required.\"),\n                v.maxLength(20, \"Batch create accepts at most 20 orders.\"),\n            ),\n        }),\n        v.check((input) => {\n            const clientOrderIds = input.items\n                .map((item) => item.clientOrderId)\n                .filter((clientOrderId) => clientOrderId !== undefined && clientOrderId !== \"\");\n            return new Set(clientOrderIds).size === clientOrderIds.length;\n        }, \"Each non-empty batch create clientOrderId must be unique.\"),\n        v.transform(({ account, ...input }) => ({\n            ...input,\n            subaccountId: accountScopeToSubaccountId(account),\n        })),\n    );\n}\n\nexport type BatchCreateOrdersInput = v.InferInput<\n    ReturnType<typeof createBatchCreateOrdersInputSchema>\n>;\n\nconst BatchCreateOrderResultRawSchema = v.object({\n    clientOrderId: v.string(),\n    outcome: v.variant(\"case\", [\n        v.object({\n            case: v.literal(\"accepted\"),\n            value: v.object({\n                orderId: PublicIdSchema,\n                takeProfitTriggerId: OptionalPublicIdSchema,\n                stopLossTriggerId: OptionalPublicIdSchema,\n                trailingStopTriggerId: OptionalPublicIdSchema,\n                resolvedBaseQtyScaled: v.bigint(),\n                submittedMaxQuoteDebitScaled: v.optional(v.bigint()),\n            }),\n        }),\n        v.object({\n            case: v.literal(\"rejected\"),\n            value: v.object({\n                // The server may reject without a structured detail (e.g. capacity\n                // limits); surface the rejection instead of failing the parse.\n                error: v.optional(OrderErrorDetailSchema),\n            }),\n        }),\n    ]),\n});\n\nexport function createBatchCreateOrdersResultSchema(scales: SdkScales, symbolIds: number[]) {\n    return v.pipe(\n        v.object({\n            results: v.array(BatchCreateOrderResultRawSchema),\n            acceptedCount: BatchCountSchema,\n            rejectedCount: BatchCountSchema,\n            tsNs: v.bigint(),\n        }),\n        v.check(\n            (response) =>\n                response.acceptedCount + response.rejectedCount === response.results.length,\n            \"Batch create result counts do not match the returned results.\",\n        ),\n        v.check(\n            (response) => response.results.length === symbolIds.length,\n            \"Batch create result count does not match the submitted item count.\",\n        ),\n        v.transform(({ tsNs, ...response }) => ({\n            ...response,\n            results: response.results.map(({ clientOrderId, outcome }, index) => {\n                if (outcome.case === \"rejected\") {\n                    return {\n                        status: \"rejected\" as const,\n                        clientOrderId,\n                        error: outcome.value.error,\n                    };\n                }\n                const { resolvedBaseQtyScaled, submittedMaxQuoteDebitScaled, ...accepted } =\n                    outcome.value;\n                const symbolId = symbolIds[index]!;\n                return {\n                    status: \"accepted\" as const,\n                    clientOrderId,\n                    ...accepted,\n                    resolvedBaseQty: scaledToDecimalOutput(\n                        resolvedBaseQtyScaled,\n                        scales.baseQty(symbolId),\n                    ),\n                    ...(submittedMaxQuoteDebitScaled === undefined\n                        ? {}\n                        : {\n                              submittedMaxQuoteDebit: scaledToDecimalOutput(\n                                  submittedMaxQuoteDebitScaled,\n                                  scales.quoteAmount(symbolId),\n                              ),\n                          }),\n                };\n            }),\n            ts: tsNsToMs(tsNs),\n            tsNs: tsNs.toString(),\n        })),\n    );\n}\n\nexport type BatchCreateOrdersResult = v.InferOutput<\n    ReturnType<typeof createBatchCreateOrdersResultSchema>\n>;\nexport type BatchCreateOrderResult = BatchCreateOrdersResult[\"results\"][number];\n\nconst DecimalInputStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));\nconst BATCH_REPLACE_ITEM_INPUT_KEYS = new Set([\n    \"orderId\",\n    \"clientOrderId\",\n    \"newPrice\",\n    \"newQty\",\n    \"risk\",\n    \"clearRisk\",\n    \"newClientOrderId\",\n]);\n\nexport function assertKnownBatchReplaceOrderItemInputKeys(input: object): void {\n    for (const key of Object.keys(input)) {\n        if (!BATCH_REPLACE_ITEM_INPUT_KEYS.has(key)) {\n            throw new Error(`Unknown key \"${key}\" in batch replace order item.`);\n        }\n    }\n}\n\nconst BatchReplaceTargetInputSchema = v.union([\n    v.pipe(\n        v.object({\n            orderId: v.pipe(\n                idInputSchema(\"items.orderId\"),\n                v.check((value) => value > 0n, \"items.orderId must be greater than zero\"),\n            ),\n            clientOrderId: v.optional(v.never()),\n        }),\n        v.transform(({ orderId }) => ({\n            key: { case: \"orderId\" as const, value: orderId },\n        })),\n    ),\n    v.pipe(\n        v.object({\n            orderId: v.optional(v.never()),\n            clientOrderId: ClientOrderIdInputSchema,\n        }),\n        v.transform(({ clientOrderId }) => ({\n            key: { case: \"clientOrderId\" as const, value: clientOrderId },\n        })),\n    ),\n]);\n\nfunction createBatchReplaceOrderItemInputSchema(scales: SdkScales) {\n    const patchSchema = v.union([\n        v.object({\n            newPrice: DecimalInputStringSchema,\n            newQty: v.optional(DecimalInputStringSchema),\n            risk: v.optional(createRequiredRiskPolicyInputSchema(scales)),\n            clearRisk: v.optional(v.literal(false)),\n        }),\n        v.object({\n            newPrice: v.optional(DecimalInputStringSchema),\n            newQty: DecimalInputStringSchema,\n            risk: v.optional(createRequiredRiskPolicyInputSchema(scales)),\n            clearRisk: v.optional(v.literal(false)),\n        }),\n        v.object({\n            newPrice: v.optional(v.never()),\n            newQty: v.optional(v.never()),\n            risk: createRequiredRiskPolicyInputSchema(scales),\n            clearRisk: v.optional(v.literal(false)),\n        }),\n        v.object({\n            newPrice: v.optional(v.never()),\n            newQty: v.optional(v.never()),\n            risk: v.optional(v.never()),\n            clearRisk: v.literal(true),\n        }),\n    ]);\n    return v.intersect([\n        BatchReplaceTargetInputSchema,\n        patchSchema,\n        v.object({\n            newClientOrderId: v.optional(ClientOrderIdInputSchema),\n        }),\n    ]);\n}\n\nexport function createBatchReplaceOrdersInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.strictObject({\n            ...AccountScopeInputEntries,\n            symbolId: SymbolIdInputSchema,\n            requestId: v.optional(OrderRequestIdInputSchema),\n            items: v.pipe(\n                v.array(createBatchReplaceOrderItemInputSchema(scales)),\n                v.minLength(1, \"At least one replacement is required.\"),\n                v.maxLength(50, \"Batch replace accepts at most 50 replacements.\"),\n            ),\n        }),\n        v.check((input) => {\n            const targets = input.items.map(\n                (item) => `${item.key.case}:${item.key.value.toString()}`,\n            );\n            return new Set(targets).size === targets.length;\n        }, \"Each batch replace target must be unique.\"),\n        v.transform(({ account, items, ...input }) => {\n            return {\n                ...input,\n                items: items.map((item) => ({\n                    key: item.key,\n                    newPriceTicks:\n                        item.newPrice === undefined\n                            ? undefined\n                            : positiveDecimalInputToScaled(\n                                  \"items.newPrice\",\n                                  item.newPrice,\n                                  scales.price(),\n                              ),\n                    newQtyScaled:\n                        item.newQty === undefined\n                            ? undefined\n                            : positiveDecimalInputToScaled(\n                                  \"items.newQty\",\n                                  item.newQty,\n                                  scales.baseQty(input.symbolId),\n                              ),\n                    newAttachedRisk:\n                        item.clearRisk === true ? create(ProtoWrite.RiskPolicySchema) : item.risk,\n                    newClientOrderId: item.newClientOrderId ?? \"\",\n                })),\n                subaccountId: accountScopeToSubaccountId(account),\n            };\n        }),\n    );\n}\n\nexport type BatchReplaceOrdersInput = {\n    account?: v.InferInput<typeof AccountScopeInputEntries.account>;\n    symbolId: number;\n    requestId?: string;\n    items: Array<{\n        orderId?: string;\n        clientOrderId?: string;\n        newPrice?: string;\n        newQty?: string;\n        risk?: v.InferInput<ReturnType<typeof createRequiredRiskPolicyInputSchema>>;\n        clearRisk?: boolean;\n        newClientOrderId?: string;\n    }>;\n};\n\nconst BatchReplaceAdmissionItemSchema = v.pipe(\n    v.object({\n        itemIndex: BatchItemIndexSchema,\n        status: enumLabelSchema(BatchReplaceItemAdmissionStatusCodec.protoToOutput),\n        oldOrderId: OptionalPublicIdSchema,\n        replacementOrderId: OptionalPublicIdSchema,\n        actionTaken: enumLabelSchema(ModifyActionCodec.protoToOutput),\n        clientOrderId: v.string(),\n        code: v.string(),\n        error: v.optional(OrderErrorDetailSchema),\n    }),\n    v.transform((item) => ({\n        ...item,\n        code: item.code || undefined,\n    })),\n);\n\nexport type BatchReplaceAdmissionItem = v.InferOutput<typeof BatchReplaceAdmissionItemSchema>;\n\nexport const BatchReplaceOrdersResultSchema = v.pipe(\n    v.object({\n        batchRequestId: PositivePublicIdSchema,\n        status: enumLabelSchema(BatchReplaceAdmissionStatusCodec.protoToOutput),\n        results: v.array(BatchReplaceAdmissionItemSchema),\n        acceptedCount: BatchCountSchema,\n        rejectedCount: BatchCountSchema,\n        acceptedTsNs: v.bigint(),\n    }),\n    v.check(\n        (response) => response.acceptedCount + response.rejectedCount === response.results.length,\n        \"Batch replace result counts do not match the returned results.\",\n    ),\n    v.check(\n        (response) => response.results.every((item, index) => item.itemIndex === index),\n        \"Batch replace results must preserve request item order.\",\n    ),\n    v.transform(({ acceptedTsNs, ...response }) => ({\n        ...response,\n        acceptedTs: tsNsToMs(acceptedTsNs),\n        acceptedTsNs: acceptedTsNs.toString(),\n    })),\n);\n\nexport type BatchReplaceOrdersResult = v.InferOutput<typeof BatchReplaceOrdersResultSchema>;\n\nexport const GetBatchReplaceStatusInputSchema = v.pipe(\n    v.strictObject({\n        ...AccountScopeInputEntries,\n        batchRequestId: v.pipe(\n            idInputSchema(\"batchRequestId\"),\n            v.check((value) => value > 0n, \"batchRequestId must be greater than zero\"),\n        ),\n    }),\n    v.transform(({ account, ...input }) => ({\n        ...input,\n        subaccountId: accountScopeToSubaccountId(account),\n    })),\n);\n\nexport type GetBatchReplaceStatusInput = v.InferInput<typeof GetBatchReplaceStatusInputSchema>;\n\nconst BatchReplaceStatusItemSchema = v.pipe(\n    v.object({\n        itemIndex: BatchItemIndexSchema,\n        phase: enumLabelSchema(BatchReplacePhaseCodec.protoToOutput),\n        oldOrderId: OptionalPublicIdSchema,\n        replacementOrderId: OptionalPublicIdSchema,\n        actionTaken: enumLabelSchema(ModifyActionCodec.protoToOutput),\n        orderStatus: enumLabelSchema(OrderStatusCodec.protoToOutput),\n        code: v.string(),\n        updatedTsNs: v.bigint(),\n    }),\n    v.transform(({ updatedTsNs, ...item }) => ({\n        ...item,\n        code: item.code || undefined,\n        updatedTs: tsNsToMs(updatedTsNs),\n        updatedTsNs: updatedTsNs.toString(),\n    })),\n);\n\nexport const GetBatchReplaceStatusResultSchema = v.pipe(\n    v.object({\n        batchRequestId: PositivePublicIdSchema,\n        admissionStatus: enumLabelSchema(BatchReplaceAdmissionStatusCodec.protoToOutput),\n        items: v.array(BatchReplaceStatusItemSchema),\n        acceptedCount: BatchCountSchema,\n        rejectedCount: BatchCountSchema,\n        acceptedTsNs: v.bigint(),\n        updatedTsNs: v.bigint(),\n    }),\n    v.check(\n        (response) => response.acceptedCount + response.rejectedCount === response.items.length,\n        \"Batch replace status counts do not match the returned items.\",\n    ),\n    v.check(\n        (response) => response.items.every((item, index) => item.itemIndex === index),\n        \"Batch replace status items must preserve request item order.\",\n    ),\n    v.transform(({ acceptedTsNs, updatedTsNs, ...response }) => ({\n        ...response,\n        acceptedTs: tsNsToMs(acceptedTsNs),\n        acceptedTsNs: acceptedTsNs.toString(),\n        updatedTs: tsNsToMs(updatedTsNs),\n        updatedTsNs: updatedTsNs.toString(),\n    })),\n);\n\nexport type GetBatchReplaceStatusResult = v.InferOutput<typeof GetBatchReplaceStatusResultSchema>;\n\nconst BatchCancelOrderInputSchema = v.union([\n    v.pipe(\n        v.strictObject({\n            orderId: positiveOrderIdInputSchema(\"items.orderId\"),\n            clientOrderId: v.optional(v.never()),\n            symbolId: v.optional(SymbolIdInputSchema),\n        }),\n        v.transform(({ orderId, symbolId }) => ({ orderId, symbolId })),\n    ),\n    v.pipe(\n        v.strictObject({\n            orderId: v.optional(v.never()),\n            clientOrderId: ClientOrderIdInputSchema,\n            symbolId: v.optional(SymbolIdInputSchema),\n        }),\n        v.transform(({ clientOrderId, symbolId }) => ({ clientOrderId, symbolId })),\n    ),\n]);\n\nexport type BatchCancelOrderInput = v.InferInput<typeof BatchCancelOrderInputSchema>;\n\nexport const BatchCancelOrdersInputSchema = v.pipe(\n    v.strictObject({\n        ...AccountScopeInputEntries,\n        requestId: v.optional(OrderRequestIdInputSchema),\n        items: v.pipe(\n            v.array(BatchCancelOrderInputSchema),\n            v.minLength(1, \"At least one order is required.\"),\n            v.maxLength(50, \"Batch cancel accepts at most 50 orders.\"),\n        ),\n    }),\n    v.transform(({ account, ...input }) => ({\n        ...input,\n        subaccountId: accountScopeToSubaccountId(account),\n    })),\n);\n\nexport type BatchCancelOrdersInput = v.InferInput<typeof BatchCancelOrdersInputSchema>;\n\nconst BatchCancelOrderResultSchema = v.object({\n    status: enumLabelSchema(BatchCancelOrderStatusCodec.protoToOutput),\n    orderId: OptionalPublicIdSchema,\n    clientOrderId: v.string(),\n    code: v.string(),\n    error: v.optional(OrderErrorDetailSchema),\n});\n\nexport type BatchCancelOrderResult = v.InferOutput<typeof BatchCancelOrderResultSchema>;\n\nexport const BatchCancelOrdersResultSchema = v.pipe(\n    v.object({\n        results: v.array(BatchCancelOrderResultSchema),\n        acceptedCount: BatchCountSchema,\n        rejectedCount: BatchCountSchema,\n        tsNs: v.bigint(),\n    }),\n    v.check(\n        (response) => response.acceptedCount + response.rejectedCount === response.results.length,\n        \"Batch cancel result counts do not match the returned results.\",\n    ),\n    v.transform(({ tsNs, ...response }) => ({\n        ...response,\n        ts: tsNsToMs(tsNs),\n        tsNs: tsNs.toString(),\n    })),\n);\n\nexport type BatchCancelOrdersResult = v.InferOutput<typeof BatchCancelOrdersResultSchema>;\n"],"mappings":"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"}

package/dist/services/orders/orders.d.ts

@@ -39,11 +39,11 @@ declare class OrdersService {
    */
   preview(input: NewOrderInput, options?: PolyesterRequestOptions): Promise<PreviewOrderResult>;
   /**
-   * Places a spot order with an explicit market-IOC, limit-GTC, limit-IOC, or limit-FOK execution policy and optional attached risk controls. clientOrderId is an account-scoped correlation, lookup, and cancellation identifier. Reuse while retained returns CONFLICT_DUPLICATE_CLIENT_ORDER_ID, including after rejection or completion; it does not replay the earlier result.
+   * Places a spot order with an explicit market-IOC, limit-GTC, limit-IOC, or limit-FOK execution policy and optional attached risk controls. clientOrderId is an account-scoped correlation, lookup, and cancellation identifier. Reuse while retained returns CONFLICT_DUPLICATE_CLIENT_ORDER_ID, including after rejection or completion; it does not replay the earlier result. After an ambiguous timeout, reconcile through get using clientOrderId; an immediate lookup miss does not prove admission failed. Without clientOrderId, the outcome may remain unknown.
    */
   create(input: NewOrderInput, options?: PolyesterMutationOptions): Promise<CreateOrderResult>;
   /**
-   * Places 1–20 spot orders in one best-effort request. Results preserve item order and report admission as accepted or rejected; accepted orders still require lifecycle reconciliation. requestId is the idempotency boundary for the ordered batch and is generated when omitted; supply and reuse it when an ambiguous batch may be retried. Per-item clientOrderId values are optional correlation identifiers and must be unique when supplied.
+   * Places 1–20 spot orders in one best-effort request. Results preserve item order and report admission as accepted or rejected; accepted orders still require lifecycle reconciliation. requestId is the idempotency boundary for the ordered batch and is generated when omitted; supply and reuse it when an ambiguous batch may be retried. The same payload and account-scoped requestId replay the original results and timestamp within 15 minutes; a different payload during that window returns CONFLICT_IDEMPOTENCY_KEY_REUSE. Per-item clientOrderId values are optional correlation identifiers and must be unique when supplied.
    */
   batchCreate(input: BatchCreateOrdersInput, options?: PolyesterMutationOptions): Promise<BatchCreateOrdersResult>;
   /**
@@ -59,11 +59,11 @@ declare class OrdersService {
    */
   modify(input: ModifyOrderInput, options?: PolyesterMutationOptions): Promise<ModifyOrderResult>;
   /**
-   * Replaces 1–50 same-symbol orders and returns an index-stable durable admission receipt. Reuse requestId only when retrying the same logical batch; use the returned batchRequestId for later status reads.
+   * Replaces 1–50 same-symbol orders and returns an index-stable durable admission receipt. Reuse requestId only when retrying the same logical batch; use the returned batchRequestId for later status reads. An AMENDED actionTaken is cancel-only with no successor; keep tracking oldOrderId until its terminal state is confirmed.
    */
   batchReplace(input: BatchReplaceOrdersInput, options?: PolyesterMutationOptions): Promise<BatchReplaceOrdersResult>;
   /**
-   * Reads the durable per-item execution status for a batch replacement receipt.
+   * Reads the durable per-item execution status for a batch replacement receipt. For cancel-only AMENDED items, orderStatus describes oldOrderId and replacementOrderId is undefined.
    */
   getBatchReplaceStatus(input: GetBatchReplaceStatusInput, options?: PolyesterRequestOptions): Promise<GetBatchReplaceStatusResult>;
   /**

package/dist/services/orders/orders.js

@@ -104,7 +104,7 @@ var OrdersService = class {
 		return parse(createPreviewOrderResultSchema(this.#scales, request.order.symbolId), response);
 	}
 	/**
-	* Places a spot order with an explicit market-IOC, limit-GTC, limit-IOC, or limit-FOK execution policy and optional attached risk controls. clientOrderId is an account-scoped correlation, lookup, and cancellation identifier. Reuse while retained returns CONFLICT_DUPLICATE_CLIENT_ORDER_ID, including after rejection or completion; it does not replay the earlier result.
+	* Places a spot order with an explicit market-IOC, limit-GTC, limit-IOC, or limit-FOK execution policy and optional attached risk controls. clientOrderId is an account-scoped correlation, lookup, and cancellation identifier. Reuse while retained returns CONFLICT_DUPLICATE_CLIENT_ORDER_ID, including after rejection or completion; it does not replay the earlier result. After an ambiguous timeout, reconcile through get using clientOrderId; an immediate lookup miss does not prove admission failed. Without clientOrderId, the outcome may remain unknown.
 	*/
 	async create(input, options) {
 		await this.#scales.ready();
@@ -115,7 +115,7 @@ var OrdersService = class {
 		return parse(createCreateOrderResultSchema(this.#scales, validatedInput.order.symbolId), res);
 	}
 	/**
-	* Places 1–20 spot orders in one best-effort request. Results preserve item order and report admission as accepted or rejected; accepted orders still require lifecycle reconciliation. requestId is the idempotency boundary for the ordered batch and is generated when omitted; supply and reuse it when an ambiguous batch may be retried. Per-item clientOrderId values are optional correlation identifiers and must be unique when supplied.
+	* Places 1–20 spot orders in one best-effort request. Results preserve item order and report admission as accepted or rejected; accepted orders still require lifecycle reconciliation. requestId is the idempotency boundary for the ordered batch and is generated when omitted; supply and reuse it when an ambiguous batch may be retried. The same payload and account-scoped requestId replay the original results and timestamp within 15 minutes; a different payload during that window returns CONFLICT_IDEMPOTENCY_KEY_REUSE. Per-item clientOrderId values are optional correlation identifiers and must be unique when supplied.
 	*/
 	async batchCreate(input, options) {
 		await this.#scales.ready();
@@ -171,7 +171,7 @@ var OrdersService = class {
 		return parse(ModifyOrderResultSchema, res);
 	}
 	/**
-	* Replaces 1–50 same-symbol orders and returns an index-stable durable admission receipt. Reuse requestId only when retrying the same logical batch; use the returned batchRequestId for later status reads.
+	* Replaces 1–50 same-symbol orders and returns an index-stable durable admission receipt. Reuse requestId only when retrying the same logical batch; use the returned batchRequestId for later status reads. An AMENDED actionTaken is cancel-only with no successor; keep tracking oldOrderId until its terminal state is confirmed.
 	*/
 	async batchReplace(input, options) {
 		await this.#scales.ready();
@@ -187,7 +187,7 @@ var OrdersService = class {
 		return result;
 	}
 	/**
-	* Reads the durable per-item execution status for a batch replacement receipt.
+	* Reads the durable per-item execution status for a batch replacement receipt. For cancel-only AMENDED items, orderStatus describes oldOrderId and replacementOrderId is undefined.
 	*/
 	async getBatchReplaceStatus(input, options) {
 		const resolved = resolveAccountScopedInput(input, this.#resolver);