@polyester/sdk 0.4.0 → 0.4.2

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":";;;;;;;;cAuDa,2BAAyB,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;KAc1B,sBAAsB,qBAAE,kBAAkB;cAEzC,4BAA0B,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;KAgB3B,uBAAuB,qBAAE,mBAAmB;iBAExC,mCAAmC,QAAQ,YAAS,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkBxD,yBAAyB,qBAAE,WACnC,kBAAkB;iBA0BN,oCAAoC,QAAQ,WAAW,oBAAiB,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsD5E,0BAA0B,qBAAE,YACpC,kBAAkB;KAEV,yBAAyB;KAkIzB;EACR,UAAU,qBAAE,kBAAkB,yBAAyB;EACvD;EACA;EACA,OAAO;IACH;IACA;IACA;IACA;IACA,OAAO,qBAAE,WAAW,kBAAkB;IACtC;IACA;;;cAIF,iCAA+B,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0BzB,4BAA4B,qBAAE,mBAAmB;cAEhD,gCAA8B,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkC/B,2BAA2B,qBAAE,mBAAmB;cAE/C,kCAAgC,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;KAcjC,6BAA6B,qBAAE,kBAAkB;cAwChD,mCAAiC,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqClC,8BAA8B,qBAAE,mBAAmB;cAEzD,6BAA2B,qBAAA,aAAA,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;KAsBrB,wBAAwB,qBAAE,kBAAkB;cAE3C,8BAA4B,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAgB7B,yBAAyB,qBAAE,kBAAkB;cAEnD,8BAA4B,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;KAQtB,yBAAyB,qBAAE,mBAAmB;cAE7C,+BAA6B,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkB9B,0BAA0B,qBAAE,mBAAmB"}
+{"version":3,"file":"orders-batch.schemas.d.ts","names":[],"sources":["../../../src/services/orders/orders-batch.schemas.ts"],"mappings":";;;;;;;;cAuDa,2BAAyB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;KAc1B,sBAAsB,EAAE,kBAAkB;cAEzC,4BAA0B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;KAgB3B,uBAAuB,EAAE,mBAAmB;iBAExC,mCAAmC,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkBxD,yBAAyB,EAAE,WACnC,kBAAkB;iBA0BN,oCAAoC,QAAQ,WAAW,oBAAiB,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsD5E,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0BzB,4BAA4B,EAAE,mBAAmB;cAEhD,gCAA8B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkC/B,2BAA2B,EAAE,mBAAmB;cAE/C,kCAAgC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;KAcjC,6BAA6B,EAAE,kBAAkB;cAwChD,mCAAiC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAqClC,8BAA8B,EAAE,mBAAmB;cAEzD,6BAA2B,EAAA,aAAA,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;KAsBrB,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

@@ -1,4 +1,3 @@
-import { validation_exports } from "../../shared/validation.js";
 import { BatchReplaceAdmissionStatus, BatchReplaceItemAdmissionStatus, RiskPolicySchema } from "../../gen/orders/v1/orders_pb.js";
 import { requiredEnumLabel } from "../../shared/proto-enum-codec.js";
 import { formatId } from "../../utils/base58-id.js";
@@ -15,29 +14,30 @@ import { createRequiredRiskPolicyInputSchema } from "./orders-risk.schemas.js";
 import { ClientOrderIdInputSchema, OrderRequestIdInputSchema } from "./orders-identifiers.schemas.js";
 import { createOrderIntentInputSchema } from "./orders-input.schemas.js";
 import { create } from "@bufbuild/protobuf";
+import * as v from "valibot";
 //#region src/services/orders/orders-batch.schemas.ts
-const BatchCountSchema = validation_exports.pipe(validation_exports.number(), validation_exports.integer(), validation_exports.minValue(0));
-const BatchItemIndexSchema = validation_exports.pipe(validation_exports.number(), validation_exports.integer(), validation_exports.minValue(0));
-const PositivePublicIdSchema = validation_exports.pipe(validation_exports.bigint(), validation_exports.gtValue(0n), validation_exports.transform((value) => formatId(value)));
-const OptionalSymbolInputSchema = validation_exports.optional(validation_exports.pipe(validation_exports.string(), validation_exports.trim(), validation_exports.maxLength(32)));
-const OptionalSideInputSchema = validation_exports.pipe(validation_exports.optional(SideSchema), validation_exports.transform((side) => side ? OrderSideCodec.inputToProto[side] : void 0));
-const CancelAllAfterTimeoutInputSchema = validation_exports.pipe(validation_exports.number(), validation_exports.integer(), validation_exports.check((timeoutSec) => timeoutSec === 0 || timeoutSec >= 10 && timeoutSec <= 120, "timeoutSec must be 0 to disable or between 10 and 120 seconds to arm"));
-const CancelAllAfterInputSchema = validation_exports.pipe(validation_exports.strictObject({
+const BatchCountSchema = v.pipe(v.number(), v.integer(), v.minValue(0));
+const BatchItemIndexSchema = v.pipe(v.number(), v.integer(), v.minValue(0));
+const PositivePublicIdSchema = v.pipe(v.bigint(), v.gtValue(0n), v.transform((value) => formatId(value)));
+const OptionalSymbolInputSchema = v.optional(v.pipe(v.string(), v.trim(), v.maxLength(32)));
+const OptionalSideInputSchema = v.pipe(v.optional(SideSchema), v.transform((side) => side ? OrderSideCodec.inputToProto[side] : void 0));
+const CancelAllAfterTimeoutInputSchema = v.pipe(v.number(), v.integer(), v.check((timeoutSec) => timeoutSec === 0 || timeoutSec >= 10 && timeoutSec <= 120, "timeoutSec must be 0 to disable or between 10 and 120 seconds to arm"));
+const CancelAllAfterInputSchema = v.pipe(v.strictObject({
 	...AccountScopeInputEntries,
 	timeoutSec: CancelAllAfterTimeoutInputSchema,
 	symbol: OptionalSymbolInputSchema,
 	side: OptionalSideInputSchema,
-	requestId: validation_exports.optional(OrderRequestIdInputSchema)
-}), validation_exports.transform(({ account, ...input }) => ({
+	requestId: v.optional(OrderRequestIdInputSchema)
+}), v.transform(({ account, ...input }) => ({
 	...input,
 	subaccountId: accountScopeToSubaccountId(account)
 })));
-const CancelAllAfterResultSchema = validation_exports.pipe(validation_exports.object({
-	status: validation_exports.picklist(["armed", "disabled"]),
-	effectiveTimeoutSec: validation_exports.pipe(validation_exports.number(), validation_exports.integer(), validation_exports.minValue(0)),
-	expiresAtTsNs: validation_exports.bigint(),
-	tsNs: validation_exports.bigint()
-}), validation_exports.transform(({ expiresAtTsNs, tsNs, ...result }) => ({
+const CancelAllAfterResultSchema = v.pipe(v.object({
+	status: v.picklist(["armed", "disabled"]),
+	effectiveTimeoutSec: v.pipe(v.number(), v.integer(), v.minValue(0)),
+	expiresAtTsNs: v.bigint(),
+	tsNs: v.bigint()
+}), v.transform(({ expiresAtTsNs, tsNs, ...result }) => ({
 	...result,
 	expiresAt: tsNsToMs(expiresAtTsNs),
 	expiresAtNs: expiresAtTsNs.toString(),
@@ -45,39 +45,39 @@ const CancelAllAfterResultSchema = validation_exports.pipe(validation_exports.ob
 	tsNs: tsNs.toString()
 })));
 function createBatchCreateOrdersInputSchema(scales) {
-	return validation_exports.pipe(validation_exports.strictObject({
+	return v.pipe(v.strictObject({
 		...AccountScopeInputEntries,
-		requestId: validation_exports.optional(OrderRequestIdInputSchema),
-		items: validation_exports.pipe(validation_exports.array(createOrderIntentInputSchema(scales)), validation_exports.minLength(1, "At least one order is required."), validation_exports.maxLength(20, "Batch create accepts at most 20 orders."))
-	}), validation_exports.transform(({ account, ...input }) => ({
+		requestId: v.optional(OrderRequestIdInputSchema),
+		items: v.pipe(v.array(createOrderIntentInputSchema(scales)), v.minLength(1, "At least one order is required."), v.maxLength(20, "Batch create accepts at most 20 orders."))
+	}), v.transform(({ account, ...input }) => ({
 		...input,
 		subaccountId: accountScopeToSubaccountId(account)
 	})));
 }
-const BatchCreateOrderResultRawSchema = validation_exports.object({
-	clientOrderId: validation_exports.string(),
-	outcome: validation_exports.variant("case", [validation_exports.object({
-		case: validation_exports.literal("accepted"),
-		value: validation_exports.object({
+const BatchCreateOrderResultRawSchema = v.object({
+	clientOrderId: v.string(),
+	outcome: v.variant("case", [v.object({
+		case: v.literal("accepted"),
+		value: v.object({
 			orderId: PublicIdSchema,
 			takeProfitTriggerId: OptionalPublicIdSchema,
 			stopLossTriggerId: OptionalPublicIdSchema,
 			trailingStopTriggerId: OptionalPublicIdSchema,
-			resolvedBaseQtyScaled: validation_exports.bigint(),
-			submittedMaxQuoteDebitScaled: validation_exports.optional(validation_exports.bigint())
+			resolvedBaseQtyScaled: v.bigint(),
+			submittedMaxQuoteDebitScaled: v.optional(v.bigint())
 		})
-	}), validation_exports.object({
-		case: validation_exports.literal("rejected"),
-		value: validation_exports.object({ error: OrderErrorDetailSchema })
+	}), v.object({
+		case: v.literal("rejected"),
+		value: v.object({ error: OrderErrorDetailSchema })
 	})])
 });
 function createBatchCreateOrdersResultSchema(scales, symbols) {
-	return validation_exports.pipe(validation_exports.object({
-		results: validation_exports.array(BatchCreateOrderResultRawSchema),
+	return v.pipe(v.object({
+		results: v.array(BatchCreateOrderResultRawSchema),
 		acceptedCount: BatchCountSchema,
 		rejectedCount: BatchCountSchema,
-		tsNs: validation_exports.bigint()
-	}), validation_exports.check((response) => response.acceptedCount + response.rejectedCount === response.results.length, "Batch create result counts do not match the returned results."), validation_exports.check((response) => response.results.length === symbols.length, "Batch create result count does not match the submitted item count."), validation_exports.transform(({ tsNs, ...response }) => ({
+		tsNs: v.bigint()
+	}), v.check((response) => response.acceptedCount + response.rejectedCount === response.results.length, "Batch create result counts do not match the returned results."), v.check((response) => response.results.length === symbols.length, "Batch create result count does not match the submitted item count."), v.transform(({ tsNs, ...response }) => ({
 		...response,
 		results: response.results.map(({ clientOrderId, outcome }, index) => {
 			if (outcome.case === "rejected") return {
@@ -99,7 +99,7 @@ function createBatchCreateOrdersResultSchema(scales, symbols) {
 		tsNs: tsNs.toString()
 	})));
 }
-const DecimalInputStringSchema = validation_exports.pipe(validation_exports.string(), validation_exports.trim(), validation_exports.minLength(1));
+const DecimalInputStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));
 const BATCH_REPLACE_ITEM_INPUT_KEYS = /* @__PURE__ */ new Set([
 	"orderId",
 	"clientOrderId",
@@ -112,51 +112,51 @@ const BATCH_REPLACE_ITEM_INPUT_KEYS = /* @__PURE__ */ new Set([
 function assertKnownBatchReplaceOrderItemInputKeys(input) {
 	for (const key of Object.keys(input)) if (!BATCH_REPLACE_ITEM_INPUT_KEYS.has(key)) throw new Error(`Unknown key "${key}" in batch replace order item.`);
 }
-const BatchReplaceTargetInputSchema = validation_exports.union([validation_exports.pipe(validation_exports.object({
-	orderId: validation_exports.pipe(idInputSchema("items.orderId"), validation_exports.check((value) => value > 0n, "items.orderId must be greater than zero")),
-	clientOrderId: validation_exports.optional(validation_exports.never())
-}), validation_exports.transform(({ orderId }) => ({ key: {
+const BatchReplaceTargetInputSchema = v.union([v.pipe(v.object({
+	orderId: v.pipe(idInputSchema("items.orderId"), v.check((value) => value > 0n, "items.orderId must be greater than zero")),
+	clientOrderId: v.optional(v.never())
+}), v.transform(({ orderId }) => ({ key: {
 	case: "orderId",
 	value: orderId
-} }))), validation_exports.pipe(validation_exports.object({
-	orderId: validation_exports.optional(validation_exports.never()),
+} }))), v.pipe(v.object({
+	orderId: v.optional(v.never()),
 	clientOrderId: ClientOrderIdInputSchema
-}), validation_exports.transform(({ clientOrderId }) => ({ key: {
+}), v.transform(({ clientOrderId }) => ({ key: {
 	case: "clientOrderId",
 	value: clientOrderId
 } })))]);
 function createBatchReplaceOrderItemInputSchema(scales, symbolId) {
-	const patchSchema = validation_exports.union([
-		validation_exports.object({
+	const patchSchema = v.union([
+		v.object({
 			newPrice: DecimalInputStringSchema,
-			newQty: validation_exports.optional(DecimalInputStringSchema),
-			risk: validation_exports.optional(createRequiredRiskPolicyInputSchema(scales)),
-			clearRisk: validation_exports.optional(validation_exports.literal(false))
+			newQty: v.optional(DecimalInputStringSchema),
+			risk: v.optional(createRequiredRiskPolicyInputSchema(scales)),
+			clearRisk: v.optional(v.literal(false))
 		}),
-		validation_exports.object({
-			newPrice: validation_exports.optional(DecimalInputStringSchema),
+		v.object({
+			newPrice: v.optional(DecimalInputStringSchema),
 			newQty: DecimalInputStringSchema,
-			risk: validation_exports.optional(createRequiredRiskPolicyInputSchema(scales)),
-			clearRisk: validation_exports.optional(validation_exports.literal(false))
+			risk: v.optional(createRequiredRiskPolicyInputSchema(scales)),
+			clearRisk: v.optional(v.literal(false))
 		}),
-		validation_exports.object({
-			newPrice: validation_exports.optional(validation_exports.never()),
-			newQty: validation_exports.optional(validation_exports.never()),
+		v.object({
+			newPrice: v.optional(v.never()),
+			newQty: v.optional(v.never()),
 			risk: createRequiredRiskPolicyInputSchema(scales),
-			clearRisk: validation_exports.optional(validation_exports.literal(false))
+			clearRisk: v.optional(v.literal(false))
 		}),
-		validation_exports.object({
-			newPrice: validation_exports.optional(validation_exports.never()),
-			newQty: validation_exports.optional(validation_exports.never()),
-			risk: validation_exports.optional(validation_exports.never()),
-			clearRisk: validation_exports.literal(true)
+		v.object({
+			newPrice: v.optional(v.never()),
+			newQty: v.optional(v.never()),
+			risk: v.optional(v.never()),
+			clearRisk: v.literal(true)
 		})
 	]);
-	return validation_exports.pipe(validation_exports.intersect([
+	return v.pipe(v.intersect([
 		BatchReplaceTargetInputSchema,
 		patchSchema,
-		validation_exports.object({ newClientOrderId: validation_exports.optional(ClientOrderIdInputSchema) })
-	]), validation_exports.transform((input) => ({
+		v.object({ newClientOrderId: v.optional(ClientOrderIdInputSchema) })
+	]), v.transform((input) => ({
 		key: input.key,
 		newPriceTicks: input.newPrice === void 0 ? void 0 : positiveDecimalInputToScaled("items.newPrice", input.newPrice, scales.price()),
 		newQtyScaled: input.newQty === void 0 ? void 0 : positiveDecimalInputToScaled("items.newQty", input.newQty, scales.baseQty(symbolId)),
@@ -165,115 +165,115 @@ function createBatchReplaceOrderItemInputSchema(scales, symbolId) {
 	})));
 }
 function createBatchReplaceOrdersInputSchema(scales, symbolId) {
-	return validation_exports.pipe(validation_exports.strictObject({
+	return v.pipe(v.strictObject({
 		...AccountScopeInputEntries,
-		symbolId: validation_exports.pipe(validation_exports.literal(symbolId), validation_exports.integer(), validation_exports.minValue(1)),
-		requestId: validation_exports.optional(OrderRequestIdInputSchema),
-		items: validation_exports.pipe(validation_exports.array(createBatchReplaceOrderItemInputSchema(scales, symbolId)), validation_exports.minLength(1, "At least one replacement is required."), validation_exports.maxLength(50, "Batch replace accepts at most 50 replacements."))
-	}), validation_exports.check((input) => {
+		symbolId: v.pipe(v.literal(symbolId), v.integer(), v.minValue(1)),
+		requestId: v.optional(OrderRequestIdInputSchema),
+		items: v.pipe(v.array(createBatchReplaceOrderItemInputSchema(scales, symbolId)), v.minLength(1, "At least one replacement is required."), v.maxLength(50, "Batch replace accepts at most 50 replacements."))
+	}), v.check((input) => {
 		const targets = input.items.map((item) => `${item.key.case}:${item.key.value.toString()}`);
 		return new Set(targets).size === targets.length;
-	}, "Each batch replace target must be unique."), validation_exports.transform(({ account, ...input }) => ({
+	}, "Each batch replace target must be unique."), v.transform(({ account, ...input }) => ({
 		...input,
 		subaccountId: accountScopeToSubaccountId(account)
 	})));
 }
-const BatchReplaceAdmissionItemSchema = validation_exports.pipe(validation_exports.object({
+const BatchReplaceAdmissionItemSchema = v.pipe(v.object({
 	itemIndex: BatchItemIndexSchema,
-	status: validation_exports.pipe(validation_exports.enum(BatchReplaceItemAdmissionStatus), validation_exports.transform((status) => requiredEnumLabel(BatchReplaceItemAdmissionStatusCodec.protoToOutput, status, "BatchReplaceAdmissionItemSchema", "status"))),
+	status: v.pipe(v.enum(BatchReplaceItemAdmissionStatus), v.transform((status) => requiredEnumLabel(BatchReplaceItemAdmissionStatusCodec.protoToOutput, status, "BatchReplaceAdmissionItemSchema", "status"))),
 	oldOrderId: OptionalPublicIdSchema,
 	replacementOrderId: OptionalPublicIdSchema,
-	clientOrderId: validation_exports.string(),
-	code: validation_exports.string(),
-	error: validation_exports.optional(OrderErrorDetailSchema)
-}), validation_exports.transform((item) => ({
+	clientOrderId: v.string(),
+	code: v.string(),
+	error: v.optional(OrderErrorDetailSchema)
+}), v.transform((item) => ({
 	...item,
 	code: item.code || void 0
 })));
-const BatchReplaceOrdersResultSchema = validation_exports.pipe(validation_exports.object({
+const BatchReplaceOrdersResultSchema = v.pipe(v.object({
 	batchRequestId: PositivePublicIdSchema,
-	status: validation_exports.pipe(validation_exports.enum(BatchReplaceAdmissionStatus), validation_exports.transform((status) => requiredEnumLabel(BatchReplaceAdmissionStatusCodec.protoToOutput, status, "BatchReplaceOrdersResultSchema", "status"))),
-	results: validation_exports.array(BatchReplaceAdmissionItemSchema),
+	status: v.pipe(v.enum(BatchReplaceAdmissionStatus), v.transform((status) => requiredEnumLabel(BatchReplaceAdmissionStatusCodec.protoToOutput, status, "BatchReplaceOrdersResultSchema", "status"))),
+	results: v.array(BatchReplaceAdmissionItemSchema),
 	acceptedCount: BatchCountSchema,
 	rejectedCount: BatchCountSchema,
-	acceptedTsNs: validation_exports.bigint()
-}), validation_exports.check((response) => response.acceptedCount + response.rejectedCount === response.results.length, "Batch replace result counts do not match the returned results."), validation_exports.check((response) => response.results.every((item, index) => item.itemIndex === index), "Batch replace results must preserve request item order."), validation_exports.transform(({ acceptedTsNs, ...response }) => ({
+	acceptedTsNs: v.bigint()
+}), v.check((response) => response.acceptedCount + response.rejectedCount === response.results.length, "Batch replace result counts do not match the returned results."), v.check((response) => response.results.every((item, index) => item.itemIndex === index), "Batch replace results must preserve request item order."), v.transform(({ acceptedTsNs, ...response }) => ({
 	...response,
 	acceptedTs: tsNsToMs(acceptedTsNs),
 	acceptedTsNs: acceptedTsNs.toString()
 })));
-const GetBatchReplaceStatusInputSchema = validation_exports.pipe(validation_exports.strictObject({
+const GetBatchReplaceStatusInputSchema = v.pipe(v.strictObject({
 	...AccountScopeInputEntries,
-	batchRequestId: validation_exports.pipe(idInputSchema("batchRequestId"), validation_exports.check((value) => value > 0n, "batchRequestId must be greater than zero"))
-}), validation_exports.transform(({ account, ...input }) => ({
+	batchRequestId: v.pipe(idInputSchema("batchRequestId"), v.check((value) => value > 0n, "batchRequestId must be greater than zero"))
+}), v.transform(({ account, ...input }) => ({
 	...input,
 	subaccountId: accountScopeToSubaccountId(account)
 })));
-const BatchReplaceStatusItemSchema = validation_exports.pipe(validation_exports.object({
+const BatchReplaceStatusItemSchema = v.pipe(v.object({
 	itemIndex: BatchItemIndexSchema,
-	phase: validation_exports.pipe(validation_exports.enum(BatchReplacePhase), validation_exports.transform((phase) => requiredEnumLabel(BatchReplacePhaseCodec.protoToOutput, phase, "BatchReplaceStatusItemSchema", "phase"))),
+	phase: v.pipe(v.enum(BatchReplacePhase), v.transform((phase) => requiredEnumLabel(BatchReplacePhaseCodec.protoToOutput, phase, "BatchReplaceStatusItemSchema", "phase"))),
 	oldOrderId: OptionalPublicIdSchema,
 	replacementOrderId: OptionalPublicIdSchema,
-	orderStatus: validation_exports.pipe(validation_exports.enum(OrderStatus), validation_exports.transform((status) => requiredEnumLabel(OrderStatusCodec.protoToOutput, status, "BatchReplaceStatusItemSchema", "order status"))),
-	code: validation_exports.string(),
-	updatedTsNs: validation_exports.bigint()
-}), validation_exports.transform(({ updatedTsNs, ...item }) => ({
+	orderStatus: v.pipe(v.enum(OrderStatus), v.transform((status) => requiredEnumLabel(OrderStatusCodec.protoToOutput, status, "BatchReplaceStatusItemSchema", "order status"))),
+	code: v.string(),
+	updatedTsNs: v.bigint()
+}), v.transform(({ updatedTsNs, ...item }) => ({
 	...item,
 	code: item.code || void 0,
 	updatedTs: tsNsToMs(updatedTsNs),
 	updatedTsNs: updatedTsNs.toString()
 })));
-const GetBatchReplaceStatusResultSchema = validation_exports.pipe(validation_exports.object({
+const GetBatchReplaceStatusResultSchema = v.pipe(v.object({
 	batchRequestId: PositivePublicIdSchema,
-	admissionStatus: validation_exports.pipe(validation_exports.enum(BatchReplaceAdmissionStatus), validation_exports.transform((status) => requiredEnumLabel(BatchReplaceAdmissionStatusCodec.protoToOutput, status, "GetBatchReplaceStatusResultSchema", "admission status"))),
-	items: validation_exports.array(BatchReplaceStatusItemSchema),
+	admissionStatus: v.pipe(v.enum(BatchReplaceAdmissionStatus), v.transform((status) => requiredEnumLabel(BatchReplaceAdmissionStatusCodec.protoToOutput, status, "GetBatchReplaceStatusResultSchema", "admission status"))),
+	items: v.array(BatchReplaceStatusItemSchema),
 	acceptedCount: BatchCountSchema,
 	rejectedCount: BatchCountSchema,
-	acceptedTsNs: validation_exports.bigint(),
-	updatedTsNs: validation_exports.bigint()
-}), validation_exports.check((response) => response.acceptedCount + response.rejectedCount === response.items.length, "Batch replace status counts do not match the returned items."), validation_exports.check((response) => response.items.every((item, index) => item.itemIndex === index), "Batch replace status items must preserve request item order."), validation_exports.transform(({ acceptedTsNs, updatedTsNs, ...response }) => ({
+	acceptedTsNs: v.bigint(),
+	updatedTsNs: v.bigint()
+}), v.check((response) => response.acceptedCount + response.rejectedCount === response.items.length, "Batch replace status counts do not match the returned items."), v.check((response) => response.items.every((item, index) => item.itemIndex === index), "Batch replace status items must preserve request item order."), v.transform(({ acceptedTsNs, updatedTsNs, ...response }) => ({
 	...response,
 	acceptedTs: tsNsToMs(acceptedTsNs),
 	acceptedTsNs: acceptedTsNs.toString(),
 	updatedTs: tsNsToMs(updatedTsNs),
 	updatedTsNs: updatedTsNs.toString()
 })));
-const BatchCancelOrderInputSchema = validation_exports.union([validation_exports.pipe(validation_exports.strictObject({
-	orderId: validation_exports.pipe(idInputSchema("items.orderId"), validation_exports.check((value) => value > 0n, "items.orderId must be greater than zero")),
-	clientOrderId: validation_exports.optional(validation_exports.never()),
-	symbolId: validation_exports.optional(validation_exports.pipe(validation_exports.number(), validation_exports.integer(), validation_exports.minValue(1)))
-}), validation_exports.transform(({ orderId, symbolId }) => ({
+const BatchCancelOrderInputSchema = v.union([v.pipe(v.strictObject({
+	orderId: v.pipe(idInputSchema("items.orderId"), v.check((value) => value > 0n, "items.orderId must be greater than zero")),
+	clientOrderId: v.optional(v.never()),
+	symbolId: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1)))
+}), v.transform(({ orderId, symbolId }) => ({
 	orderId,
 	symbolId
-}))), validation_exports.pipe(validation_exports.strictObject({
-	orderId: validation_exports.optional(validation_exports.never()),
+}))), v.pipe(v.strictObject({
+	orderId: v.optional(v.never()),
 	clientOrderId: ClientOrderIdInputSchema,
-	symbolId: validation_exports.optional(validation_exports.pipe(validation_exports.number(), validation_exports.integer(), validation_exports.minValue(1)))
-}), validation_exports.transform(({ clientOrderId, symbolId }) => ({
+	symbolId: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1)))
+}), v.transform(({ clientOrderId, symbolId }) => ({
 	clientOrderId,
 	symbolId
 })))]);
-const BatchCancelOrdersInputSchema = validation_exports.pipe(validation_exports.strictObject({
+const BatchCancelOrdersInputSchema = v.pipe(v.strictObject({
 	...AccountScopeInputEntries,
-	requestId: validation_exports.optional(OrderRequestIdInputSchema),
-	items: validation_exports.pipe(validation_exports.array(BatchCancelOrderInputSchema), validation_exports.minLength(1, "At least one order is required."), validation_exports.maxLength(50, "Batch cancel accepts at most 50 orders."))
-}), validation_exports.transform(({ account, ...input }) => ({
+	requestId: v.optional(OrderRequestIdInputSchema),
+	items: v.pipe(v.array(BatchCancelOrderInputSchema), v.minLength(1, "At least one order is required."), v.maxLength(50, "Batch cancel accepts at most 50 orders."))
+}), v.transform(({ account, ...input }) => ({
 	...input,
 	subaccountId: accountScopeToSubaccountId(account)
 })));
-const BatchCancelOrderResultSchema = validation_exports.object({
-	status: validation_exports.picklist(["accepted", "rejected"]),
+const BatchCancelOrderResultSchema = v.object({
+	status: v.picklist(["accepted", "rejected"]),
 	orderId: OptionalPublicIdSchema,
-	clientOrderId: validation_exports.string(),
-	code: validation_exports.string(),
-	error: validation_exports.optional(OrderErrorDetailSchema)
+	clientOrderId: v.string(),
+	code: v.string(),
+	error: v.optional(OrderErrorDetailSchema)
 });
-const BatchCancelOrdersResultSchema = validation_exports.pipe(validation_exports.object({
-	results: validation_exports.array(BatchCancelOrderResultSchema),
+const BatchCancelOrdersResultSchema = v.pipe(v.object({
+	results: v.array(BatchCancelOrderResultSchema),
 	acceptedCount: BatchCountSchema,
 	rejectedCount: BatchCountSchema,
-	tsNs: validation_exports.bigint()
-}), validation_exports.check((response) => response.acceptedCount + response.rejectedCount === response.results.length, "Batch cancel result counts do not match the returned results."), validation_exports.transform(({ tsNs, ...response }) => ({
+	tsNs: v.bigint()
+}), v.check((response) => response.acceptedCount + response.rejectedCount === response.results.length, "Batch cancel result counts do not match the returned results."), v.transform(({ tsNs, ...response }) => ({
 	...response,
 	ts: tsNsToMs(tsNs),
 	tsNs: tsNs.toString()

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

@@ -1 +1 @@
-{"version":3,"file":"orders-batch.schemas.js","names":["v","ProtoWrite.RiskPolicySchema","ProtoWrite.BatchReplaceItemAdmissionStatus","ProtoWrite.BatchReplaceAdmissionStatus","ProtoRead.BatchReplacePhase","ProtoRead.OrderStatus"],"sources":["../../../src/services/orders/orders-batch.schemas.ts"],"sourcesContent":["import * as ProtoWrite from \"../../gen/orders/v1/orders_pb.js\";\nimport * as ProtoRead from \"../../gen/orders/v1/orders_read_pb.js\";\nimport { create } from \"@bufbuild/protobuf\";\nimport * as v from \"../../shared/validation.js\";\nimport {\n    AccountScopeInputEntries,\n    accountScopeToSubaccountId,\n} from \"../../shared/account-scope.js\";\nimport { OptionalPublicIdSchema, PublicIdSchema, idInputSchema } from \"../../shared/schemas.js\";\nimport { requiredEnumLabel } from \"../../shared/proto-enum-codec.js\";\nimport { tsNsToMs } from \"../../utils/time.js\";\nimport { formatId } from \"../../utils/base58-id.js\";\nimport { SideSchema } from \"../shared.js\";\nimport {\n    positiveDecimalInputToScaled,\n    scaledToDecimalOutput,\n    type SdkScales,\n} from \"../../shared/decimal-surface.js\";\nimport {\n    BatchReplaceAdmissionStatusCodec,\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    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 OptionalSymbolInputSchema = v.optional(v.pipe(v.string(), v.trim(), v.maxLength(32)));\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        symbol: OptionalSymbolInputSchema,\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: v.picklist([\"armed\", \"disabled\"]),\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.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                error: OrderErrorDetailSchema,\n            }),\n        }),\n    ]),\n});\n\nexport function createBatchCreateOrdersResultSchema(scales: SdkScales, symbols: string[]) {\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 === symbols.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 symbol = symbols[index]!;\n                return {\n                    status: \"accepted\" as const,\n                    clientOrderId,\n                    ...accepted,\n                    resolvedBaseQty: scaledToDecimalOutput(\n                        resolvedBaseQtyScaled,\n                        scales.baseQty(symbol),\n                    ),\n                    ...(submittedMaxQuoteDebitScaled === undefined\n                        ? {}\n                        : {\n                              submittedMaxQuoteDebit: scaledToDecimalOutput(\n                                  submittedMaxQuoteDebitScaled,\n                                  scales.quoteAmount(symbol),\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, symbolId: number) {\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.pipe(\n        v.intersect([\n            BatchReplaceTargetInputSchema,\n            patchSchema,\n            v.object({\n                newClientOrderId: v.optional(ClientOrderIdInputSchema),\n            }),\n        ]),\n        v.transform((input) => ({\n            key: input.key,\n            newPriceTicks:\n                input.newPrice === undefined\n                    ? undefined\n                    : positiveDecimalInputToScaled(\n                          \"items.newPrice\",\n                          input.newPrice,\n                          scales.price(),\n                      ),\n            newQtyScaled:\n                input.newQty === undefined\n                    ? undefined\n                    : positiveDecimalInputToScaled(\n                          \"items.newQty\",\n                          input.newQty,\n                          scales.baseQty(symbolId),\n                      ),\n            newAttachedRisk:\n                input.clearRisk === true ? create(ProtoWrite.RiskPolicySchema) : input.risk,\n            newClientOrderId: input.newClientOrderId ?? \"\",\n        })),\n    );\n}\n\nexport function createBatchReplaceOrdersInputSchema(scales: SdkScales, symbolId: number) {\n    return v.pipe(\n        v.strictObject({\n            ...AccountScopeInputEntries,\n            symbolId: v.pipe(v.literal(symbolId), v.integer(), v.minValue(1)),\n            requestId: v.optional(OrderRequestIdInputSchema),\n            items: v.pipe(\n                v.array(createBatchReplaceOrderItemInputSchema(scales, symbolId)),\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, ...input }) => ({\n            ...input,\n            subaccountId: accountScopeToSubaccountId(account),\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: v.pipe(\n            v.enum(ProtoWrite.BatchReplaceItemAdmissionStatus),\n            v.transform((status) =>\n                requiredEnumLabel(\n                    BatchReplaceItemAdmissionStatusCodec.protoToOutput,\n                    status,\n                    \"BatchReplaceAdmissionItemSchema\",\n                    \"status\",\n                ),\n            ),\n        ),\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: v.pipe(\n            v.enum(ProtoWrite.BatchReplaceAdmissionStatus),\n            v.transform((status) =>\n                requiredEnumLabel(\n                    BatchReplaceAdmissionStatusCodec.protoToOutput,\n                    status,\n                    \"BatchReplaceOrdersResultSchema\",\n                    \"status\",\n                ),\n            ),\n        ),\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: v.pipe(\n            v.enum(ProtoRead.BatchReplacePhase),\n            v.transform((phase) =>\n                requiredEnumLabel(\n                    BatchReplacePhaseCodec.protoToOutput,\n                    phase,\n                    \"BatchReplaceStatusItemSchema\",\n                    \"phase\",\n                ),\n            ),\n        ),\n        oldOrderId: OptionalPublicIdSchema,\n        replacementOrderId: OptionalPublicIdSchema,\n        orderStatus: v.pipe(\n            v.enum(ProtoRead.OrderStatus),\n            v.transform((status) =>\n                requiredEnumLabel(\n                    OrderStatusCodec.protoToOutput,\n                    status,\n                    \"BatchReplaceStatusItemSchema\",\n                    \"order status\",\n                ),\n            ),\n        ),\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: v.pipe(\n            v.enum(ProtoWrite.BatchReplaceAdmissionStatus),\n            v.transform((status) =>\n                requiredEnumLabel(\n                    BatchReplaceAdmissionStatusCodec.protoToOutput,\n                    status,\n                    \"GetBatchReplaceStatusResultSchema\",\n                    \"admission status\",\n                ),\n            ),\n        ),\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: 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            symbolId: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),\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(v.pipe(v.number(), v.integer(), v.minValue(1))),\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: v.picklist([\"accepted\", \"rejected\"]),\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","ProtoWrite.BatchReplaceItemAdmissionStatus","ProtoWrite.BatchReplaceAdmissionStatus","ProtoRead.BatchReplacePhase","ProtoRead.OrderStatus"],"sources":["../../../src/services/orders/orders-batch.schemas.ts"],"sourcesContent":["import * as ProtoWrite from \"../../gen/orders/v1/orders_pb.js\";\nimport * as ProtoRead from \"../../gen/orders/v1/orders_read_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 { requiredEnumLabel } from \"../../shared/proto-enum-codec.js\";\nimport { tsNsToMs } from \"../../utils/time.js\";\nimport { formatId } from \"../../utils/base58-id.js\";\nimport { SideSchema } from \"../shared.js\";\nimport {\n    positiveDecimalInputToScaled,\n    scaledToDecimalOutput,\n    type SdkScales,\n} from \"../../shared/decimal-surface.js\";\nimport {\n    BatchReplaceAdmissionStatusCodec,\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    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 OptionalSymbolInputSchema = v.optional(v.pipe(v.string(), v.trim(), v.maxLength(32)));\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        symbol: OptionalSymbolInputSchema,\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: v.picklist([\"armed\", \"disabled\"]),\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.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                error: OrderErrorDetailSchema,\n            }),\n        }),\n    ]),\n});\n\nexport function createBatchCreateOrdersResultSchema(scales: SdkScales, symbols: string[]) {\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 === symbols.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 symbol = symbols[index]!;\n                return {\n                    status: \"accepted\" as const,\n                    clientOrderId,\n                    ...accepted,\n                    resolvedBaseQty: scaledToDecimalOutput(\n                        resolvedBaseQtyScaled,\n                        scales.baseQty(symbol),\n                    ),\n                    ...(submittedMaxQuoteDebitScaled === undefined\n                        ? {}\n                        : {\n                              submittedMaxQuoteDebit: scaledToDecimalOutput(\n                                  submittedMaxQuoteDebitScaled,\n                                  scales.quoteAmount(symbol),\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, symbolId: number) {\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.pipe(\n        v.intersect([\n            BatchReplaceTargetInputSchema,\n            patchSchema,\n            v.object({\n                newClientOrderId: v.optional(ClientOrderIdInputSchema),\n            }),\n        ]),\n        v.transform((input) => ({\n            key: input.key,\n            newPriceTicks:\n                input.newPrice === undefined\n                    ? undefined\n                    : positiveDecimalInputToScaled(\n                          \"items.newPrice\",\n                          input.newPrice,\n                          scales.price(),\n                      ),\n            newQtyScaled:\n                input.newQty === undefined\n                    ? undefined\n                    : positiveDecimalInputToScaled(\n                          \"items.newQty\",\n                          input.newQty,\n                          scales.baseQty(symbolId),\n                      ),\n            newAttachedRisk:\n                input.clearRisk === true ? create(ProtoWrite.RiskPolicySchema) : input.risk,\n            newClientOrderId: input.newClientOrderId ?? \"\",\n        })),\n    );\n}\n\nexport function createBatchReplaceOrdersInputSchema(scales: SdkScales, symbolId: number) {\n    return v.pipe(\n        v.strictObject({\n            ...AccountScopeInputEntries,\n            symbolId: v.pipe(v.literal(symbolId), v.integer(), v.minValue(1)),\n            requestId: v.optional(OrderRequestIdInputSchema),\n            items: v.pipe(\n                v.array(createBatchReplaceOrderItemInputSchema(scales, symbolId)),\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, ...input }) => ({\n            ...input,\n            subaccountId: accountScopeToSubaccountId(account),\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: v.pipe(\n            v.enum(ProtoWrite.BatchReplaceItemAdmissionStatus),\n            v.transform((status) =>\n                requiredEnumLabel(\n                    BatchReplaceItemAdmissionStatusCodec.protoToOutput,\n                    status,\n                    \"BatchReplaceAdmissionItemSchema\",\n                    \"status\",\n                ),\n            ),\n        ),\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: v.pipe(\n            v.enum(ProtoWrite.BatchReplaceAdmissionStatus),\n            v.transform((status) =>\n                requiredEnumLabel(\n                    BatchReplaceAdmissionStatusCodec.protoToOutput,\n                    status,\n                    \"BatchReplaceOrdersResultSchema\",\n                    \"status\",\n                ),\n            ),\n        ),\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: v.pipe(\n            v.enum(ProtoRead.BatchReplacePhase),\n            v.transform((phase) =>\n                requiredEnumLabel(\n                    BatchReplacePhaseCodec.protoToOutput,\n                    phase,\n                    \"BatchReplaceStatusItemSchema\",\n                    \"phase\",\n                ),\n            ),\n        ),\n        oldOrderId: OptionalPublicIdSchema,\n        replacementOrderId: OptionalPublicIdSchema,\n        orderStatus: v.pipe(\n            v.enum(ProtoRead.OrderStatus),\n            v.transform((status) =>\n                requiredEnumLabel(\n                    OrderStatusCodec.protoToOutput,\n                    status,\n                    \"BatchReplaceStatusItemSchema\",\n                    \"order status\",\n                ),\n            ),\n        ),\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: v.pipe(\n            v.enum(ProtoWrite.BatchReplaceAdmissionStatus),\n            v.transform((status) =>\n                requiredEnumLabel(\n                    BatchReplaceAdmissionStatusCodec.protoToOutput,\n                    status,\n                    \"GetBatchReplaceStatusResultSchema\",\n                    \"admission status\",\n                ),\n            ),\n        ),\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: 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            symbolId: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),\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(v.pipe(v.number(), v.integer(), v.minValue(1))),\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: v.picklist([\"accepted\", \"rejected\"]),\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-identifiers.schemas.js

@@ -1,10 +1,10 @@
-import { validation_exports } from "../../shared/validation.js";
+import * as v from "valibot";
 //#region src/services/orders/orders-identifiers.schemas.ts
 const OrderIdempotencyKeyPattern = /^[A-Za-z0-9._:/-]*$/;
-const ClientOrderIdWireInputSchema = validation_exports.pipe(validation_exports.string(), validation_exports.trim(), validation_exports.maxLength(36), validation_exports.regex(OrderIdempotencyKeyPattern, "clientOrderId has an invalid format"));
-const ClientOrderIdInputSchema = validation_exports.pipe(ClientOrderIdWireInputSchema, validation_exports.minLength(1));
-const OptionalClientOrderIdInputSchema = validation_exports.optional(ClientOrderIdWireInputSchema);
-const OrderRequestIdInputSchema = validation_exports.pipe(validation_exports.string(), validation_exports.trim(), validation_exports.minLength(1), validation_exports.maxLength(64), validation_exports.regex(OrderIdempotencyKeyPattern, "requestId has an invalid format"));
+const ClientOrderIdWireInputSchema = v.pipe(v.string(), v.trim(), v.maxLength(36), v.regex(OrderIdempotencyKeyPattern, "clientOrderId has an invalid format"));
+const ClientOrderIdInputSchema = v.pipe(ClientOrderIdWireInputSchema, v.minLength(1));
+const OptionalClientOrderIdInputSchema = v.optional(ClientOrderIdWireInputSchema);
+const OrderRequestIdInputSchema = v.pipe(v.string(), v.trim(), v.minLength(1), v.maxLength(64), v.regex(OrderIdempotencyKeyPattern, "requestId has an invalid format"));
 //#endregion
 export { ClientOrderIdInputSchema, OptionalClientOrderIdInputSchema, OrderRequestIdInputSchema };
 

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

@@ -1 +1 @@
-{"version":3,"file":"orders-identifiers.schemas.js","names":["v"],"sources":["../../../src/services/orders/orders-identifiers.schemas.ts"],"sourcesContent":["import * as v from \"../../shared/validation.js\";\n\nconst OrderIdempotencyKeyPattern = /^[A-Za-z0-9._:/-]*$/;\n\nconst ClientOrderIdWireInputSchema = v.pipe(\n    v.string(),\n    v.trim(),\n    v.maxLength(36),\n    v.regex(OrderIdempotencyKeyPattern, \"clientOrderId has an invalid format\"),\n);\n\nexport const ClientOrderIdInputSchema = v.pipe(ClientOrderIdWireInputSchema, v.minLength(1));\n\nexport const OptionalClientOrderIdInputSchema = v.optional(ClientOrderIdWireInputSchema);\n\nexport const OrderRequestIdInputSchema = v.pipe(\n    v.string(),\n    v.trim(),\n    v.minLength(1),\n    v.maxLength(64),\n    v.regex(OrderIdempotencyKeyPattern, \"requestId has an invalid format\"),\n);\n"],"mappings":";;AAEA,MAAM,6BAA6B;AAEnC,MAAM,+BAA+BA,mBAAE,KACnCA,mBAAE,OAAO,GACTA,mBAAE,KAAK,GACPA,mBAAE,UAAU,EAAE,GACdA,mBAAE,MAAM,4BAA4B,qCAAqC,CAC7E;AAEA,MAAa,2BAA2BA,mBAAE,KAAK,8BAA8BA,mBAAE,UAAU,CAAC,CAAC;AAE3F,MAAa,mCAAmCA,mBAAE,SAAS,4BAA4B;AAEvF,MAAa,4BAA4BA,mBAAE,KACvCA,mBAAE,OAAO,GACTA,mBAAE,KAAK,GACPA,mBAAE,UAAU,CAAC,GACbA,mBAAE,UAAU,EAAE,GACdA,mBAAE,MAAM,4BAA4B,iCAAiC,CACzE"}
+{"version":3,"file":"orders-identifiers.schemas.js","names":[],"sources":["../../../src/services/orders/orders-identifiers.schemas.ts"],"sourcesContent":["import * as v from \"valibot\";\n\nconst OrderIdempotencyKeyPattern = /^[A-Za-z0-9._:/-]*$/;\n\nconst ClientOrderIdWireInputSchema = v.pipe(\n    v.string(),\n    v.trim(),\n    v.maxLength(36),\n    v.regex(OrderIdempotencyKeyPattern, \"clientOrderId has an invalid format\"),\n);\n\nexport const ClientOrderIdInputSchema = v.pipe(ClientOrderIdWireInputSchema, v.minLength(1));\n\nexport const OptionalClientOrderIdInputSchema = v.optional(ClientOrderIdWireInputSchema);\n\nexport const OrderRequestIdInputSchema = v.pipe(\n    v.string(),\n    v.trim(),\n    v.minLength(1),\n    v.maxLength(64),\n    v.regex(OrderIdempotencyKeyPattern, \"requestId has an invalid format\"),\n);\n"],"mappings":";;AAEA,MAAM,6BAA6B;AAEnC,MAAM,+BAA+B,EAAE,KACnC,EAAE,OAAO,GACT,EAAE,KAAK,GACP,EAAE,UAAU,EAAE,GACd,EAAE,MAAM,4BAA4B,qCAAqC,CAC7E;AAEA,MAAa,2BAA2B,EAAE,KAAK,8BAA8B,EAAE,UAAU,CAAC,CAAC;AAE3F,MAAa,mCAAmC,EAAE,SAAS,4BAA4B;AAEvF,MAAa,4BAA4B,EAAE,KACvC,EAAE,OAAO,GACT,EAAE,KAAK,GACP,EAAE,UAAU,CAAC,GACb,EAAE,UAAU,EAAE,GACd,EAAE,MAAM,4BAA4B,iCAAiC,CACzE"}