@polyester/sdk 0.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"orders-risk.schemas.d.ts","names":[],"sources":["../../../src/services/orders/orders-risk.schemas.ts"],"mappings":";;;;iBAkBS,2BAA2B,QAAQ,WAAW,yCAAsC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiGpF,8BAA8B,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8ExC,4BAA4B,QAAQ,YAAS,EAAA,yBAAA,EAAA,eAAA,EAAA,aAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO7C,oCAAoC,QAAQ,YAAS,EAAA,yBAAA,EAAA,aAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOzD,kBAAkB,EAAE,WAAW,kBAAkB;KACjD,gBAAgB,EAAE,WAAW,kBAAkB;KAC/C,oBAAoB,EAAE,WAAW,kBAAkB;KACnD,kBAAkB,EAAE,WAAW,kBAAkB;KAOjD;EACJ;EAAkB;;EAClB;EAAa"}

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

@@ -0,0 +1,251 @@
+import { RiskLimitGtcSchema, RiskMarketIocSchema } from "../../gen/orders/v1/orders_pb.js";
+import { positiveDecimalInputToScaled, scaledToDecimalOutput } from "../../shared/decimal-surface.js";
+import { BpsStringOrNumberInputSchema, NoneInputSchema, PriceDistanceInputSchema, PriceSlippageInputSchema } from "../shared.js";
+import { parseSlippageInput, parseTrailingDistanceInput } from "../trailing-oneof-inputs.js";
+import { create } from "@bufbuild/protobuf";
+import * as v from "valibot";
+//#region src/services/orders/orders-risk.schemas.ts
+const DecimalInputStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));
+function attachedTriggerInputSchema(scales, fieldPrefix) {
+	return v.pipe(v.strictObject({
+		triggerPrice: DecimalInputStringSchema,
+		execution: v.variant("type", [v.strictObject({ type: v.literal("market_ioc") }), v.strictObject({
+			type: v.literal("limit_gtc"),
+			price: DecimalInputStringSchema
+		})])
+	}), v.transform((input) => {
+		const execution = input.execution.type === "market_ioc" ? {
+			case: "marketIoc",
+			value: create(RiskMarketIocSchema)
+		} : {
+			case: "limitGtc",
+			value: create(RiskLimitGtcSchema, { priceTicks: positiveDecimalInputToScaled(`${fieldPrefix}.execution.price`, input.execution.price, scales.price()) })
+		};
+		return {
+			triggerPriceTicks: positiveDecimalInputToScaled(`${fieldPrefix}.triggerPrice`, input.triggerPrice, scales.price()),
+			child: { execution }
+		};
+	}));
+}
+const TrailingDistanceSchema = v.union([
+	PriceDistanceInputSchema,
+	BpsStringOrNumberInputSchema,
+	NoneInputSchema
+]);
+const MaxSlippageSchema = v.union([
+	PriceSlippageInputSchema,
+	BpsStringOrNumberInputSchema,
+	NoneInputSchema
+]);
+const MarketMaxSlippageSchema = v.union([
+	PriceSlippageInputSchema,
+	BpsStringOrNumberInputSchema,
+	NoneInputSchema
+]);
+const MAX_BPS = 1e4;
+const UNSET_TRAILING_STOP_MAX_SLIPPAGE = {
+	case: void 0,
+	value: void 0
+};
+function parseTrailingDistance(scales, distance) {
+	return parseTrailingDistanceInput(scales, distance, "trailingStop.trailingDistance");
+}
+function parseMaxSlippage(scales, slippage) {
+	return parseSlippageInput(scales, slippage, {
+		fieldName: "trailingStop.maxSlippage",
+		ticksCase: "maxSlippageTicks",
+		bpsCase: "maxSlippageBps"
+	});
+}
+function parseMarketMaxSlippage(scales, slippage) {
+	return parseSlippageInput(scales, slippage, {
+		fieldName: "execution.maxSlippage",
+		ticksCase: "maxSlippageTicks",
+		bpsCase: "maxSlippageBps",
+		maxBps: MAX_BPS
+	});
+}
+function createTrailingStopInputSchema(scales) {
+	return v.pipe(v.strictObject({
+		trailingDistance: TrailingDistanceSchema,
+		maxSlippage: v.optional(MaxSlippageSchema),
+		activationPrice: v.optional(DecimalInputStringSchema)
+	}), v.transform((input) => ({
+		trailingDistance: parseTrailingDistance(scales, input.trailingDistance),
+		maxSlippage: input.maxSlippage ? parseMaxSlippage(scales, input.maxSlippage) : UNSET_TRAILING_STOP_MAX_SLIPPAGE,
+		activationPriceTicks: input.activationPrice === void 0 ? 0n : positiveDecimalInputToScaled("trailingStop.activationPrice", input.activationPrice, scales.price())
+	})));
+}
+function createRiskPolicyObjectInputSchema(scales) {
+	const TakeProfitInputSchema = attachedTriggerInputSchema(scales, "takeProfit");
+	const StopLossInputSchema = attachedTriggerInputSchema(scales, "stopLoss");
+	const TrailingStopInputSchema = createTrailingStopInputSchema(scales);
+	return v.union([
+		v.strictObject({
+			takeProfit: TakeProfitInputSchema,
+			stopLoss: StopLossInputSchema,
+			trailingStop: v.optional(v.never()),
+			oco: v.optional(v.boolean())
+		}),
+		v.strictObject({
+			takeProfit: TakeProfitInputSchema,
+			stopLoss: v.optional(v.never()),
+			trailingStop: TrailingStopInputSchema,
+			oco: v.optional(v.boolean())
+		}),
+		v.strictObject({
+			takeProfit: TakeProfitInputSchema,
+			stopLoss: v.optional(v.never()),
+			trailingStop: v.optional(v.never()),
+			oco: v.optional(v.boolean())
+		}),
+		v.strictObject({
+			takeProfit: v.optional(v.never()),
+			stopLoss: StopLossInputSchema,
+			trailingStop: v.optional(v.never()),
+			oco: v.optional(v.boolean())
+		}),
+		v.strictObject({
+			takeProfit: v.optional(v.never()),
+			stopLoss: v.optional(v.never()),
+			trailingStop: TrailingStopInputSchema,
+			oco: v.optional(v.boolean())
+		})
+	]);
+}
+function transformRiskPolicyInput(input) {
+	const stopLeg = input.stopLoss ? {
+		case: "stopLoss",
+		value: input.stopLoss
+	} : input.trailingStop ? {
+		case: "trailingStop",
+		value: input.trailingStop
+	} : {
+		case: void 0,
+		value: void 0
+	};
+	const oco = input.oco === true && !!input.takeProfit && stopLeg.case !== void 0;
+	return {
+		takeProfit: input.takeProfit,
+		stopLeg,
+		oco
+	};
+}
+function createRiskPolicyInputSchema(scales) {
+	return v.pipe(v.optional(createRiskPolicyObjectInputSchema(scales)), v.transform((input) => input ? transformRiskPolicyInput(input) : void 0));
+}
+function createRequiredRiskPolicyInputSchema(scales) {
+	return v.pipe(createRiskPolicyObjectInputSchema(scales), v.transform((input) => transformRiskPolicyInput(input)));
+}
+const ReadRiskExecutionSchema = v.object({ execution: v.variant("case", [v.object({
+	case: v.literal("marketIoc"),
+	value: v.object({})
+}), v.object({
+	case: v.literal("limitGtc"),
+	value: v.object({ priceTicks: v.bigint() })
+})]) });
+const ReadTakeProfitPolicySchema = v.object({
+	triggerPriceTicks: v.bigint(),
+	child: ReadRiskExecutionSchema
+});
+const ReadStopLossPolicySchema = v.object({
+	triggerPriceTicks: v.bigint(),
+	child: ReadRiskExecutionSchema
+});
+const ReadTrailingStopPolicySchema = v.object({
+	trailingDistance: v.object({
+		case: v.optional(v.union([
+			v.literal("trailingDistanceTicks"),
+			v.literal("trailingDistanceBps"),
+			v.undefined()
+		])),
+		value: v.optional(v.union([
+			v.bigint(),
+			v.number(),
+			v.undefined()
+		]))
+	}),
+	maxSlippage: v.object({
+		case: v.union([
+			v.literal("maxSlippageTicks"),
+			v.literal("maxSlippageBps"),
+			v.undefined()
+		]),
+		value: v.optional(v.union([v.number(), v.undefined()]))
+	}),
+	activationPriceTicks: v.bigint()
+});
+const ReadAttachedRiskTakeProfitSchema = v.object({ policy: v.optional(ReadTakeProfitPolicySchema) });
+const ReadAttachedRiskStopLossSchema = v.object({ policy: v.optional(ReadStopLossPolicySchema) });
+const ReadAttachedRiskTrailingStopSchema = v.object({ policy: v.optional(ReadTrailingStopPolicySchema) });
+const ReadAttachedRiskSchema = v.object({
+	takeProfit: v.optional(ReadAttachedRiskTakeProfitSchema),
+	stopLoss: v.optional(ReadAttachedRiskStopLossSchema),
+	trailingStop: v.optional(ReadAttachedRiskTrailingStopSchema),
+	oco: v.optional(v.boolean(), false)
+});
+function formatRiskExecution(scales, child) {
+	if (child.execution.case === "marketIoc") return { type: "market_ioc" };
+	return {
+		type: "limit_gtc",
+		price: scaledToDecimalOutput(child.execution.value.priceTicks, scales.price())
+	};
+}
+function formatRiskLeg(scales, leg) {
+	return {
+		triggerPrice: scaledToDecimalOutput(leg.triggerPriceTicks, scales.price()),
+		execution: formatRiskExecution(scales, leg.child)
+	};
+}
+function formatTrailingDistance(scales, distance) {
+	if (distance.case === "trailingDistanceTicks" && typeof distance.value === "bigint") return {
+		kind: "distance",
+		distance: scaledToDecimalOutput(distance.value, scales.price())
+	};
+	if (distance.case === "trailingDistanceBps" && typeof distance.value === "number") return {
+		kind: "bps",
+		bps: distance.value
+	};
+	return { kind: "none" };
+}
+function formatTrailingMaxSlippage(scales, slippage) {
+	if (slippage.case === "maxSlippageTicks" && typeof slippage.value === "number") return {
+		kind: "slippage",
+		slippage: scaledToDecimalOutput(BigInt(slippage.value), scales.price())
+	};
+	if (slippage.case === "maxSlippageBps" && typeof slippage.value === "number") return {
+		kind: "bps",
+		bps: slippage.value
+	};
+}
+function formatMarketMaxSlippage(scales, ticks, bps) {
+	if (ticks > 0) return {
+		kind: "slippage",
+		slippage: scaledToDecimalOutput(BigInt(ticks), scales.price())
+	};
+	if (bps > 0) return {
+		kind: "bps",
+		bps
+	};
+}
+function formatAttachedRisk(scales, risk) {
+	if (!risk) return void 0;
+	const takeProfit = risk.takeProfit?.policy ? formatRiskLeg(scales, risk.takeProfit.policy) : void 0;
+	const stopLoss = risk.stopLoss?.policy ? formatRiskLeg(scales, risk.stopLoss.policy) : void 0;
+	const trailingStop = risk.trailingStop?.policy ? {
+		trailingDistance: formatTrailingDistance(scales, risk.trailingStop.policy.trailingDistance),
+		maxSlippage: formatTrailingMaxSlippage(scales, risk.trailingStop.policy.maxSlippage),
+		activationPrice: risk.trailingStop.policy.activationPriceTicks > 0n ? scaledToDecimalOutput(risk.trailingStop.policy.activationPriceTicks, scales.price()) : void 0
+	} : void 0;
+	if (!takeProfit && !stopLoss && !trailingStop) return void 0;
+	return {
+		takeProfit,
+		stopLoss: trailingStop ? void 0 : stopLoss,
+		trailingStop,
+		oco: risk.oco
+	};
+}
+//#endregion
+export { MarketMaxSlippageSchema, ReadAttachedRiskSchema, createRequiredRiskPolicyInputSchema, createRiskPolicyInputSchema, formatAttachedRisk, formatMarketMaxSlippage, parseMarketMaxSlippage };
+
+//# sourceMappingURL=orders-risk.schemas.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orders-risk.schemas.js","names":["ProtoWrite.RiskMarketIocSchema","ProtoWrite.RiskLimitGtcSchema"],"sources":["../../../src/services/orders/orders-risk.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    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n    PriceDistanceInputSchema,\n    PriceSlippageInputSchema,\n} from \"../shared.js\";\nimport {\n    positiveDecimalInputToScaled,\n    scaledToDecimalOutput,\n    type SdkScales,\n} from \"../../shared/decimal-surface.js\";\nimport { parseSlippageInput, parseTrailingDistanceInput } from \"../trailing-oneof-inputs.js\";\n\nconst DecimalInputStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));\n\nfunction attachedTriggerInputSchema(scales: SdkScales, fieldPrefix: \"takeProfit\" | \"stopLoss\") {\n    return v.pipe(\n        v.strictObject({\n            triggerPrice: DecimalInputStringSchema,\n            execution: v.variant(\"type\", [\n                v.strictObject({\n                    type: v.literal(\"market_ioc\"),\n                }),\n                v.strictObject({\n                    type: v.literal(\"limit_gtc\"),\n                    price: DecimalInputStringSchema,\n                }),\n            ]),\n        }),\n        v.transform((input) => {\n            const execution: ProtoWrite.RiskExecution[\"execution\"] =\n                input.execution.type === \"market_ioc\"\n                    ? {\n                          case: \"marketIoc\",\n                          value: create(ProtoWrite.RiskMarketIocSchema),\n                      }\n                    : {\n                          case: \"limitGtc\",\n                          value: create(ProtoWrite.RiskLimitGtcSchema, {\n                              priceTicks: positiveDecimalInputToScaled(\n                                  `${fieldPrefix}.execution.price`,\n                                  input.execution.price,\n                                  scales.price(),\n                              ),\n                          }),\n                      };\n            return {\n                triggerPriceTicks: positiveDecimalInputToScaled(\n                    `${fieldPrefix}.triggerPrice`,\n                    input.triggerPrice,\n                    scales.price(),\n                ),\n                child: { execution },\n            };\n        }),\n    );\n}\n\nconst TrailingDistanceSchema = v.union([\n    PriceDistanceInputSchema,\n    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n]);\n\nconst MaxSlippageSchema = v.union([\n    PriceSlippageInputSchema,\n    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n]);\n\nexport const MarketMaxSlippageSchema = v.union([\n    PriceSlippageInputSchema,\n    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n]);\n\nconst MAX_BPS = 10_000;\nconst UNSET_TRAILING_STOP_MAX_SLIPPAGE: ProtoWrite.TrailingStopPolicy[\"maxSlippage\"] = {\n    case: undefined,\n    value: undefined,\n};\n\nfunction parseTrailingDistance(\n    scales: SdkScales,\n    distance: v.InferOutput<typeof TrailingDistanceSchema>,\n): ProtoWrite.TrailingStopPolicy[\"trailingDistance\"] {\n    return parseTrailingDistanceInput(scales, distance, \"trailingStop.trailingDistance\");\n}\n\nfunction parseMaxSlippage(\n    scales: SdkScales,\n    slippage: v.InferOutput<typeof MaxSlippageSchema>,\n): ProtoWrite.TrailingStopPolicy[\"maxSlippage\"] {\n    return parseSlippageInput(scales, slippage, {\n        fieldName: \"trailingStop.maxSlippage\",\n        ticksCase: \"maxSlippageTicks\",\n        bpsCase: \"maxSlippageBps\",\n    });\n}\n\nexport function parseMarketMaxSlippage(\n    scales: SdkScales,\n    slippage: v.InferOutput<typeof MarketMaxSlippageSchema> | undefined,\n): ProtoWrite.MarketIoc[\"maxSlippage\"] {\n    return parseSlippageInput(scales, slippage, {\n        fieldName: \"execution.maxSlippage\",\n        ticksCase: \"maxSlippageTicks\",\n        bpsCase: \"maxSlippageBps\",\n        maxBps: MAX_BPS,\n    });\n}\n\nfunction createTrailingStopInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.strictObject({\n            trailingDistance: TrailingDistanceSchema,\n            maxSlippage: v.optional(MaxSlippageSchema),\n            activationPrice: v.optional(DecimalInputStringSchema),\n        }),\n        v.transform((input) => ({\n            trailingDistance: parseTrailingDistance(scales, input.trailingDistance),\n            maxSlippage: input.maxSlippage\n                ? parseMaxSlippage(scales, input.maxSlippage)\n                : UNSET_TRAILING_STOP_MAX_SLIPPAGE,\n            activationPriceTicks:\n                input.activationPrice === undefined\n                    ? 0n\n                    : positiveDecimalInputToScaled(\n                          \"trailingStop.activationPrice\",\n                          input.activationPrice,\n                          scales.price(),\n                      ),\n        })),\n    );\n}\n\nfunction createRiskPolicyObjectInputSchema(scales: SdkScales) {\n    const TakeProfitInputSchema = attachedTriggerInputSchema(scales, \"takeProfit\");\n    const StopLossInputSchema = attachedTriggerInputSchema(scales, \"stopLoss\");\n    const TrailingStopInputSchema = createTrailingStopInputSchema(scales);\n    return v.union([\n        v.strictObject({\n            takeProfit: TakeProfitInputSchema,\n            stopLoss: StopLossInputSchema,\n            trailingStop: v.optional(v.never()),\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: TakeProfitInputSchema,\n            stopLoss: v.optional(v.never()),\n            trailingStop: TrailingStopInputSchema,\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: TakeProfitInputSchema,\n            stopLoss: v.optional(v.never()),\n            trailingStop: v.optional(v.never()),\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: v.optional(v.never()),\n            stopLoss: StopLossInputSchema,\n            trailingStop: v.optional(v.never()),\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: v.optional(v.never()),\n            stopLoss: v.optional(v.never()),\n            trailingStop: TrailingStopInputSchema,\n            oco: v.optional(v.boolean()),\n        }),\n    ]);\n}\n\ntype RiskPolicyObjectInput = v.InferOutput<ReturnType<typeof createRiskPolicyObjectInputSchema>>;\n\nfunction transformRiskPolicyInput(input: RiskPolicyObjectInput) {\n    const stopLeg = input.stopLoss\n        ? ({ case: \"stopLoss\", value: input.stopLoss } as const)\n        : input.trailingStop\n          ? ({ case: \"trailingStop\", value: input.trailingStop } as const)\n          : ({ case: undefined, value: undefined } as const);\n    const oco = input.oco === true && !!input.takeProfit && stopLeg.case !== undefined;\n    return {\n        takeProfit: input.takeProfit,\n        stopLeg,\n        oco,\n    };\n}\n\nexport function createRiskPolicyInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.optional(createRiskPolicyObjectInputSchema(scales)),\n        v.transform((input) => (input ? transformRiskPolicyInput(input) : undefined)),\n    );\n}\n\nexport function createRequiredRiskPolicyInputSchema(scales: SdkScales) {\n    return v.pipe(\n        createRiskPolicyObjectInputSchema(scales),\n        v.transform((input) => transformRiskPolicyInput(input)),\n    );\n}\n\nexport type TakeProfitInput = v.InferInput<ReturnType<typeof attachedTriggerInputSchema>>;\nexport type StopLossInput = v.InferInput<ReturnType<typeof attachedTriggerInputSchema>>;\nexport type TrailingStopInput = v.InferInput<ReturnType<typeof createTrailingStopInputSchema>>;\nexport type RiskPolicyInput = v.InferInput<ReturnType<typeof createRiskPolicyInputSchema>>;\n\ntype TrailingDistance =\n    | { kind: \"distance\"; distance: string }\n    | { kind: \"bps\"; bps: number }\n    | { kind: \"none\" };\ntype TrailingMaxSlippage = { kind: \"slippage\"; slippage: string } | { kind: \"bps\"; bps: number };\nexport type MarketMaxSlippage =\n    | { kind: \"slippage\"; slippage: string }\n    | { kind: \"bps\"; bps: number };\n\nconst ReadRiskExecutionSchema = v.object({\n    execution: v.variant(\"case\", [\n        v.object({\n            case: v.literal(\"marketIoc\"),\n            value: v.object({}),\n        }),\n        v.object({\n            case: v.literal(\"limitGtc\"),\n            value: v.object({\n                priceTicks: v.bigint(),\n            }),\n        }),\n    ]),\n});\n\nconst ReadTakeProfitPolicySchema = v.object({\n    triggerPriceTicks: v.bigint(),\n    child: ReadRiskExecutionSchema,\n});\n\nconst ReadStopLossPolicySchema = v.object({\n    triggerPriceTicks: v.bigint(),\n    child: ReadRiskExecutionSchema,\n});\n\nconst ReadTrailingStopPolicySchema = v.object({\n    trailingDistance: v.object({\n        case: v.optional(\n            v.union([\n                v.literal(\"trailingDistanceTicks\"),\n                v.literal(\"trailingDistanceBps\"),\n                v.undefined(),\n            ]),\n        ),\n        value: v.optional(v.union([v.bigint(), v.number(), v.undefined()])),\n    }),\n    maxSlippage: v.object({\n        case: v.union([v.literal(\"maxSlippageTicks\"), v.literal(\"maxSlippageBps\"), v.undefined()]),\n        value: v.optional(v.union([v.number(), v.undefined()])),\n    }),\n    activationPriceTicks: v.bigint(),\n});\n\nconst ReadAttachedRiskTakeProfitSchema = v.object({\n    policy: v.optional(ReadTakeProfitPolicySchema),\n});\n\nconst ReadAttachedRiskStopLossSchema = v.object({\n    policy: v.optional(ReadStopLossPolicySchema),\n});\n\nconst ReadAttachedRiskTrailingStopSchema = v.object({\n    policy: v.optional(ReadTrailingStopPolicySchema),\n});\n\nexport const ReadAttachedRiskSchema = v.object({\n    takeProfit: v.optional(ReadAttachedRiskTakeProfitSchema),\n    stopLoss: v.optional(ReadAttachedRiskStopLossSchema),\n    trailingStop: v.optional(ReadAttachedRiskTrailingStopSchema),\n    oco: v.optional(v.boolean(), false),\n});\n\nfunction formatRiskExecution(\n    scales: SdkScales,\n    child: v.InferOutput<typeof ReadRiskExecutionSchema>,\n) {\n    if (child.execution.case === \"marketIoc\") {\n        return { type: \"market_ioc\" } as const;\n    }\n    return {\n        type: \"limit_gtc\",\n        price: scaledToDecimalOutput(child.execution.value.priceTicks, scales.price()),\n    } as const;\n}\n\nfunction formatRiskLeg(\n    scales: SdkScales,\n    leg:\n        | v.InferOutput<typeof ReadTakeProfitPolicySchema>\n        | v.InferOutput<typeof ReadStopLossPolicySchema>,\n) {\n    return {\n        triggerPrice: scaledToDecimalOutput(leg.triggerPriceTicks, scales.price()),\n        execution: formatRiskExecution(scales, leg.child),\n    };\n}\n\nfunction formatTrailingDistance(\n    scales: SdkScales,\n    distance: v.InferOutput<typeof ReadTrailingStopPolicySchema>[\"trailingDistance\"],\n): TrailingDistance {\n    if (distance.case === \"trailingDistanceTicks\" && typeof distance.value === \"bigint\") {\n        return {\n            kind: \"distance\",\n            distance: scaledToDecimalOutput(distance.value, scales.price()),\n        };\n    }\n    if (distance.case === \"trailingDistanceBps\" && typeof distance.value === \"number\") {\n        return { kind: \"bps\", bps: distance.value };\n    }\n    return { kind: \"none\" };\n}\n\nfunction formatTrailingMaxSlippage(\n    scales: SdkScales,\n    slippage: v.InferOutput<typeof ReadTrailingStopPolicySchema>[\"maxSlippage\"],\n): TrailingMaxSlippage | undefined {\n    if (slippage.case === \"maxSlippageTicks\" && typeof slippage.value === \"number\") {\n        return {\n            kind: \"slippage\",\n            slippage: scaledToDecimalOutput(BigInt(slippage.value), scales.price()),\n        };\n    }\n    if (slippage.case === \"maxSlippageBps\" && typeof slippage.value === \"number\") {\n        return { kind: \"bps\", bps: slippage.value };\n    }\n    return undefined;\n}\n\nexport function formatMarketMaxSlippage(\n    scales: SdkScales,\n    ticks: number,\n    bps: number,\n): MarketMaxSlippage | undefined {\n    if (ticks > 0) {\n        return { kind: \"slippage\", slippage: scaledToDecimalOutput(BigInt(ticks), scales.price()) };\n    }\n    if (bps > 0) {\n        return { kind: \"bps\", bps };\n    }\n    return undefined;\n}\n\nexport function formatAttachedRisk(\n    scales: SdkScales,\n    risk: v.InferOutput<typeof ReadAttachedRiskSchema> | undefined,\n) {\n    if (!risk) return undefined;\n\n    const takeProfit = risk.takeProfit?.policy\n        ? formatRiskLeg(scales, risk.takeProfit.policy)\n        : undefined;\n    const stopLoss = risk.stopLoss?.policy\n        ? formatRiskLeg(scales, risk.stopLoss.policy)\n        : undefined;\n    const trailingStop = risk.trailingStop?.policy\n        ? {\n              trailingDistance: formatTrailingDistance(\n                  scales,\n                  risk.trailingStop.policy.trailingDistance,\n              ),\n              maxSlippage: formatTrailingMaxSlippage(scales, risk.trailingStop.policy.maxSlippage),\n              activationPrice:\n                  risk.trailingStop.policy.activationPriceTicks > 0n\n                      ? scaledToDecimalOutput(\n                            risk.trailingStop.policy.activationPriceTicks,\n                            scales.price(),\n                        )\n                      : undefined,\n          }\n        : undefined;\n\n    if (!takeProfit && !stopLoss && !trailingStop) return undefined;\n\n    const effectiveStopLoss = trailingStop ? undefined : stopLoss;\n\n    return {\n        takeProfit,\n        stopLoss: effectiveStopLoss,\n        trailingStop,\n        oco: risk.oco,\n    };\n}\n"],"mappings":"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"}

package/dist/services/orders/orders.codecs.js

@@ -0,0 +1,75 @@
+import "../../gen/orders/v1/orders_pb.js";
+import "../../gen/orders/v1/orders_read_pb.js";
+import { FEE_ASSET_VALUES, FeeAssetCodec, OrderSideCodec, OrderTypeCodec, SELF_TRADE_PREVENTION_MODE_VALUES, SelfTradePreventionModeCodec, TimeInForceCodec } from "./order-enums.codecs.js";
+//#region src/services/orders/orders.codecs.ts
+const ORDER_STATUS_FILTER_VALUES = [
+	"FILLED",
+	"CANCELED",
+	"REJECTED"
+];
+const MODIFY_BEHAVIOR_VALUES = [
+	"AMEND_OR_REPLACE",
+	"AMEND_ONLY",
+	"REPLACE_ONLY"
+];
+const OrderStatusFilterCodec = { inputToProto: {
+	FILLED: 4,
+	CANCELED: 5,
+	REJECTED: 6
+} };
+const OrderStatusCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[1]: "pending",
+	[2]: "pending_cancel",
+	[3]: "working",
+	[4]: "filled",
+	[5]: "canceled",
+	[6]: "rejected"
+} };
+const OrderOriginScopeCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[1]: "direct",
+	[2]: "attached_risk",
+	[3]: "standalone_trigger",
+	[4]: "system"
+} };
+const OrderTriggerTypeCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[1]: "stop_loss",
+	[2]: "take_profit",
+	[3]: "trailing_stop",
+	[4]: "twap",
+	[5]: "ladder"
+} };
+const ModifyBehaviorCodec = { inputToProto: {
+	AMEND_OR_REPLACE: 1,
+	AMEND_ONLY: 2,
+	REPLACE_ONLY: 3
+} };
+const ModifyActionCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[1]: "AMENDED",
+	[2]: "REPLACED"
+} };
+const BatchReplaceAdmissionStatusCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[1]: "admitted",
+	[2]: "partially_admitted",
+	[3]: "rejected"
+} };
+const BatchReplaceItemAdmissionStatusCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[1]: "admitted",
+	[2]: "rejected"
+} };
+const BatchReplacePhaseCodec = { protoToOutput: {
+	[0]: "unspecified",
+	[1]: "admitted",
+	[2]: "working",
+	[3]: "rejected",
+	[4]: "terminal"
+} };
+//#endregion
+export { BatchReplaceAdmissionStatusCodec, BatchReplaceItemAdmissionStatusCodec, BatchReplacePhaseCodec, FEE_ASSET_VALUES, FeeAssetCodec, MODIFY_BEHAVIOR_VALUES, ModifyActionCodec, ModifyBehaviorCodec, ORDER_STATUS_FILTER_VALUES, OrderOriginScopeCodec, OrderSideCodec, OrderStatusCodec, OrderStatusFilterCodec, OrderTriggerTypeCodec, OrderTypeCodec, SELF_TRADE_PREVENTION_MODE_VALUES, SelfTradePreventionModeCodec, TimeInForceCodec };
+
+//# sourceMappingURL=orders.codecs.js.map

package/dist/services/orders/orders.codecs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orders.codecs.js","names":[],"sources":["../../../src/services/orders/orders.codecs.ts"],"sourcesContent":["import * as ProtoRead from \"../../gen/orders/v1/orders_read_pb.js\";\nimport * as ProtoWrite from \"../../gen/orders/v1/orders_pb.js\";\nimport type { InputToProto, ProtoToOutput } from \"../../utils/types.js\";\nexport {\n    FEE_ASSET_VALUES,\n    FeeAssetCodec,\n    type FeeAssetValue,\n    ORDER_SIDE_VALUES,\n    ORDER_TYPE_VALUES,\n    OrderSideCodec,\n    type OrderSideValue,\n    OrderTypeCodec,\n    type OrderTypeValue,\n    SELF_TRADE_PREVENTION_MODE_VALUES,\n    SelfTradePreventionModeCodec,\n    type SelfTradePreventionModeValue,\n    TIME_IN_FORCE_OUTPUT_VALUES,\n    TIME_IN_FORCE_VALUES,\n    TimeInForceCodec,\n    type TimeInForceOutputValue,\n    type TimeInForceValue,\n    TRIGGER_PRICE_SOURCE_VALUES,\n    TriggerPriceSourceCodec,\n    type TriggerPriceSourceValue,\n} from \"./order-enums.codecs.js\";\n\nexport const ORDER_STATUS_FILTER_VALUES = [\"FILLED\", \"CANCELED\", \"REJECTED\"] as const;\nexport type OrderStatusFilterValue = (typeof ORDER_STATUS_FILTER_VALUES)[number];\n\nexport const ORDER_STATUS_VALUES = [\n    \"pending\",\n    \"pending_cancel\",\n    \"working\",\n    \"filled\",\n    \"canceled\",\n    \"rejected\",\n] as const;\nexport type OrderStatusValue = (typeof ORDER_STATUS_VALUES)[number];\n\nexport const ORDER_ORIGIN_SCOPE_VALUES = [\n    \"direct\",\n    \"attached_risk\",\n    \"standalone_trigger\",\n    \"system\",\n] as const;\nexport type OrderOriginScope = (typeof ORDER_ORIGIN_SCOPE_VALUES)[number];\n\nexport const ORDER_TRIGGER_TYPE_VALUES = [\n    \"unspecified\",\n    \"stop_loss\",\n    \"take_profit\",\n    \"trailing_stop\",\n    \"twap\",\n    \"ladder\",\n] as const;\nexport type OrderTriggerType = (typeof ORDER_TRIGGER_TYPE_VALUES)[number];\n\nexport const MODIFY_BEHAVIOR_VALUES = [\"AMEND_OR_REPLACE\", \"AMEND_ONLY\", \"REPLACE_ONLY\"] as const;\nexport type ModifyBehaviorValue = (typeof MODIFY_BEHAVIOR_VALUES)[number];\n\nexport const MODIFY_ACTION_VALUES = [\"AMENDED\", \"REPLACED\"] as const;\nexport type ModifyActionValue = (typeof MODIFY_ACTION_VALUES)[number];\n\nexport const BATCH_REPLACE_ADMISSION_STATUS_VALUES = [\n    \"admitted\",\n    \"partially_admitted\",\n    \"rejected\",\n] as const;\nexport type BatchReplaceAdmissionStatusValue =\n    (typeof BATCH_REPLACE_ADMISSION_STATUS_VALUES)[number];\n\nexport const BATCH_REPLACE_ITEM_ADMISSION_STATUS_VALUES = [\"admitted\", \"rejected\"] as const;\nexport type BatchReplaceItemAdmissionStatusValue =\n    (typeof BATCH_REPLACE_ITEM_ADMISSION_STATUS_VALUES)[number];\n\nexport const BATCH_REPLACE_PHASE_VALUES = [\"admitted\", \"working\", \"rejected\", \"terminal\"] as const;\nexport type BatchReplacePhaseValue = (typeof BATCH_REPLACE_PHASE_VALUES)[number];\n\nexport const OrderStatusFilterCodec = {\n    inputToProto: {\n        FILLED: ProtoRead.OrderStatus.FILLED,\n        CANCELED: ProtoRead.OrderStatus.CANCELED,\n        REJECTED: ProtoRead.OrderStatus.REJECTED,\n    } satisfies InputToProto<OrderStatusFilterValue, ProtoRead.OrderStatus>,\n} as const;\n\nexport const OrderStatusCodec = {\n    protoToOutput: {\n        [ProtoRead.OrderStatus.ORDER_STATUS_UNSPECIFIED]: \"unspecified\",\n        [ProtoRead.OrderStatus.PENDING]: \"pending\",\n        [ProtoRead.OrderStatus.PENDING_CANCEL]: \"pending_cancel\",\n        [ProtoRead.OrderStatus.WORKING]: \"working\",\n        [ProtoRead.OrderStatus.FILLED]: \"filled\",\n        [ProtoRead.OrderStatus.CANCELED]: \"canceled\",\n        [ProtoRead.OrderStatus.REJECTED]: \"rejected\",\n    } satisfies ProtoToOutput<ProtoRead.OrderStatus, OrderStatusValue>,\n} as const;\n\nexport const OrderOriginScopeCodec = {\n    protoToOutput: {\n        [ProtoRead.OrderOriginScope.ORDER_ORIGIN_SCOPE_UNSPECIFIED]: \"unspecified\",\n        [ProtoRead.OrderOriginScope.DIRECT]: \"direct\",\n        [ProtoRead.OrderOriginScope.ATTACHED_RISK]: \"attached_risk\",\n        [ProtoRead.OrderOriginScope.STANDALONE_TRIGGER]: \"standalone_trigger\",\n        [ProtoRead.OrderOriginScope.SYSTEM]: \"system\",\n    } satisfies ProtoToOutput<ProtoRead.OrderOriginScope, OrderOriginScope>,\n} as const;\n\nexport const OrderTriggerTypeCodec = {\n    protoToOutput: {\n        [ProtoRead.OrderTriggerType.ORDER_TRIGGER_TYPE_UNSPECIFIED]: \"unspecified\",\n        [ProtoRead.OrderTriggerType.STOP_LOSS]: \"stop_loss\",\n        [ProtoRead.OrderTriggerType.TAKE_PROFIT]: \"take_profit\",\n        [ProtoRead.OrderTriggerType.TRAILING_STOP]: \"trailing_stop\",\n        [ProtoRead.OrderTriggerType.TWAP]: \"twap\",\n        [ProtoRead.OrderTriggerType.LADDER]: \"ladder\",\n    } satisfies Record<ProtoRead.OrderTriggerType, OrderTriggerType>,\n} as const;\n\nexport const ModifyBehaviorCodec = {\n    inputToProto: {\n        AMEND_OR_REPLACE: ProtoWrite.ModifyBehavior.AMEND_OR_REPLACE,\n        AMEND_ONLY: ProtoWrite.ModifyBehavior.AMEND_ONLY,\n        REPLACE_ONLY: ProtoWrite.ModifyBehavior.REPLACE_ONLY,\n    } satisfies InputToProto<ModifyBehaviorValue, ProtoWrite.ModifyBehavior>,\n} as const;\n\nexport const ModifyActionCodec = {\n    protoToOutput: {\n        [ProtoWrite.ModifyActionTaken.MODIFY_ACTION_UNSPECIFIED]: \"unspecified\",\n        [ProtoWrite.ModifyActionTaken.AMENDED]: \"AMENDED\",\n        [ProtoWrite.ModifyActionTaken.REPLACED]: \"REPLACED\",\n    } satisfies ProtoToOutput<ProtoWrite.ModifyActionTaken, ModifyActionValue>,\n} as const;\n\nexport const BatchReplaceAdmissionStatusCodec = {\n    protoToOutput: {\n        [ProtoWrite.BatchReplaceAdmissionStatus.UNSPECIFIED]: \"unspecified\",\n        [ProtoWrite.BatchReplaceAdmissionStatus.ADMITTED]: \"admitted\",\n        [ProtoWrite.BatchReplaceAdmissionStatus.PARTIALLY_ADMITTED]: \"partially_admitted\",\n        [ProtoWrite.BatchReplaceAdmissionStatus.REJECTED]: \"rejected\",\n    } satisfies ProtoToOutput<\n        ProtoWrite.BatchReplaceAdmissionStatus,\n        BatchReplaceAdmissionStatusValue\n    >,\n} as const;\n\nexport const BatchReplaceItemAdmissionStatusCodec = {\n    protoToOutput: {\n        [ProtoWrite.BatchReplaceItemAdmissionStatus.UNSPECIFIED]: \"unspecified\",\n        [ProtoWrite.BatchReplaceItemAdmissionStatus.ADMITTED]: \"admitted\",\n        [ProtoWrite.BatchReplaceItemAdmissionStatus.REJECTED]: \"rejected\",\n    } satisfies ProtoToOutput<\n        ProtoWrite.BatchReplaceItemAdmissionStatus,\n        BatchReplaceItemAdmissionStatusValue\n    >,\n} as const;\n\nexport const BatchReplacePhaseCodec = {\n    protoToOutput: {\n        [ProtoRead.BatchReplacePhase.UNSPECIFIED]: \"unspecified\",\n        [ProtoRead.BatchReplacePhase.ADMITTED]: \"admitted\",\n        [ProtoRead.BatchReplacePhase.WORKING]: \"working\",\n        [ProtoRead.BatchReplacePhase.REJECTED]: \"rejected\",\n        [ProtoRead.BatchReplacePhase.TERMINAL]: \"terminal\",\n    } satisfies ProtoToOutput<ProtoRead.BatchReplacePhase, BatchReplacePhaseValue>,\n} as const;\n"],"mappings":";;;;AA0BA,MAAa,6BAA6B;CAAC;CAAU;CAAY;AAAU;AA+B3E,MAAa,yBAAyB;CAAC;CAAoB;CAAc;AAAc;AAqBvF,MAAa,yBAAyB,EAClC,cAAc;CACV,QAAA;CACA,UAAA;CACA,UAAA;AACJ,EACJ;AAEA,MAAa,mBAAmB,EAC5B,eAAe;EACuC,IAAA;EACjB,IAAA;EACO,IAAA;EACP,IAAA;EACD,IAAA;EACE,IAAA;EACA,IAAA;AACtC,EACJ;AAEA,MAAa,wBAAwB,EACjC,eAAe;EACkD,IAAA;EACxB,IAAA;EACO,IAAA;EACK,IAAA;EACZ,IAAA;AACzC,EACJ;AAEA,MAAa,wBAAwB,EACjC,eAAe;EACkD,IAAA;EACrB,IAAA;EACE,IAAA;EACE,IAAA;EACT,IAAA;EACE,IAAA;AACzC,EACJ;AAEA,MAAa,sBAAsB,EAC/B,cAAc;CACV,kBAAA;CACA,YAAA;CACA,cAAA;AACJ,EACJ;AAEA,MAAa,oBAAoB,EAC7B,eAAe;EAC+C,IAAA;EAClB,IAAA;EACC,IAAA;AAC7C,EACJ;AAEA,MAAa,mCAAmC,EAC5C,eAAe;EAC2C,IAAA;EACH,IAAA;EACU,IAAA;EACV,IAAA;AACvD,EAIJ;AAEA,MAAa,uCAAuC,EAChD,eAAe;EAC+C,IAAA;EACH,IAAA;EACA,IAAA;AAC3D,EAIJ;AAEA,MAAa,yBAAyB,EAClC,eAAe;EACgC,IAAA;EACH,IAAA;EACD,IAAA;EACC,IAAA;EACA,IAAA;AAC5C,EACJ"}

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

@@ -0,0 +1,88 @@
+import { PolyesterMutationOptions, PolyesterRequestOptions } from "../../shared/request-options.js";
+import { SubaccountResolver } from "../subaccount-resolver.js";
+import { PolyesterRealtime } from "../../realtime/types.js";
+import { BaseSubscribeInput } from "../../shared/types.js";
+import { SdkScales } from "../../shared/decimal-surface.js";
+import { CancelAllOrdersInputSchema, CancelAllOrdersResponse, CancelOrderInputSchema, CancelOrderResult, CreateOrderResult, GetOrderDetailsInputSchema, NewOrderInput, OpenOrdersInputSchema, OrderHistoryInputSchema, PreviewOrderResult } from "./orders-input.schemas.js";
+import { ModifyOrderInput, ModifyOrderResult } from "./orders-modify.schemas.js";
+import { BatchCancelOrdersInput, BatchCancelOrdersResult, BatchCreateOrdersInput, BatchCreateOrdersResult, BatchReplaceOrdersInput, BatchReplaceOrdersResult, CancelAllAfterInput, CancelAllAfterResult, GetBatchReplaceStatusInput, GetBatchReplaceStatusResult } from "./orders-batch.schemas.js";
+import { Order, OrderDetails } from "./orders-output.schemas.js";
+import "./orders.schemas.js";
+import { Transport } from "@connectrpc/connect";
+import * as v from "valibot";
+//#region src/services/orders/orders.d.ts
+interface SubscribeOrdersInput extends BaseSubscribeInput<Order> {
+  accountId: string;
+}
+/**
+ * Manages account-scoped spot orders across read, write, and realtime order update surfaces.
+ */
+declare class OrdersService {
+  #private;
+  constructor(transport: Transport, realtime: PolyesterRealtime, resolver: SubaccountResolver | undefined, scales: SdkScales);
+  /**
+   * Returns open orders for the resolved root account or subaccount, with optional symbol, side, pagination, and attached-risk inclusion filters. Results include the next page token returned by GetOpenOrders.
+   */
+  listOpen(input?: v.InferInput<typeof OpenOrdersInputSchema>, options?: PolyesterRequestOptions): Promise<{
+    orders: Order[];
+    nextPageToken: string;
+  }>;
+  /**
+   * Returns historical orders for the resolved account scope, supporting symbol, side, status, time range, pagination, and attached-risk filters. Results are paginated with the backend nextPageToken.
+   */
+  listHistory(input?: v.InferInput<typeof OrderHistoryInputSchema>, options?: PolyesterRequestOptions): Promise<{
+    orders: Order[];
+    nextPageToken: string;
+  }>;
+  /**
+   * Evaluates one complete order intent against current market, policy, risk, and balance state without creating an order, reserving funds, or claiming its client order ID.
+   */
+  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 the caller-controlled idempotency key and should be reused only for the same logical order.
+   */
+  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. Supply a clientOrderId for each item and a stable requestId when an ambiguous batch may be retried.
+   */
+  batchCreate(input: BatchCreateOrdersInput, options?: PolyesterMutationOptions): Promise<BatchCreateOrdersResult>;
+  /**
+   * Cancels one open order in the resolved account scope by order id or client order id, with optional symbol routing. Returns the backend cancellation status, order id, and server timestamp fields.
+   */
+  cancel(input: v.InferInput<typeof CancelOrderInputSchema>, options?: PolyesterMutationOptions): Promise<CancelOrderResult>;
+  /**
+   * Cancels 1–50 explicit orders in one best-effort request. Results preserve item order and acknowledge cancellation admission rather than final order state. Supply a stable requestId when an ambiguous batch may be retried.
+   */
+  batchCancel(input: BatchCancelOrdersInput, options?: PolyesterMutationOptions): Promise<BatchCancelOrdersResult>;
+  /**
+   * Applies a price, quantity, client id, or attached-risk patch to one open order using the backend modify behavior policy. A requestId is generated when omitted; provide a stable value when retrying the same logical modification.
+   */
+  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.
+   */
+  batchReplace(input: BatchReplaceOrdersInput, options?: PolyesterMutationOptions): Promise<BatchReplaceOrdersResult>;
+  /**
+   * Reads the durable per-item execution status for a batch replacement receipt.
+   */
+  getBatchReplaceStatus(input: GetBatchReplaceStatusInput, options?: PolyesterRequestOptions): Promise<GetBatchReplaceStatusResult>;
+  /**
+   * Cancels all matching open orders for the resolved account scope, optionally narrowed by symbol and side, with dry-run preview. A requestId is generated when omitted; provide a stable value when retrying the same logical bulk cancellation.
+   */
+  cancelAll(input: v.InferInput<typeof CancelAllOrdersInputSchema>, options?: PolyesterMutationOptions): Promise<CancelAllOrdersResponse>;
+  /**
+   * Arms, refreshes, or disables the account dead-man switch. timeoutSec 0 disables it; 10–120 arms it. Generate a new requestId for each deliberate heartbeat, but reuse the same ID when retrying one ambiguous heartbeat.
+   */
+  cancelAllAfter(input: CancelAllAfterInput, options?: PolyesterMutationOptions): Promise<CancelAllAfterResult>;
+  /**
+   * Fetches one order by id or client order id and returns its order, trades, and transfer details when found. Returns null when the backend response has no order.
+   */
+  getDetails(input: v.InferInput<typeof GetOrderDetailsInputSchema>, options?: PolyesterRequestOptions): Promise<OrderDetails | null>;
+  /**
+   * Subscribes to private order updates on private:spot:orders:{accountId}:proto and emits parsed order records until the returned unsubscribe function is called.
+   */
+  subscribe(input: SubscribeOrdersInput): () => void;
+}
+//#endregion
+export { OrdersService };
+//# sourceMappingURL=orders.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orders.d.ts","names":[],"sources":["../../../src/services/orders/orders.ts"],"mappings":";;;;;;;;;;;;;UAwEU,6BAA6B,mBAAmB;EACtD;;;;;cAqBS;;EAaL,YAAA,WAAW,WACX,UAAU,mBACV,UAAU,gCACV,QAAQ;;;;EAiBN,SACF,QAAO,EAAE,kBAAkB,wBAC3B,UAAU,0BACX;IAAU,QAAQ;IAAS;;;;;EAoBxB,YACF,QAAO,EAAE,kBAAkB,0BAC3B,UAAU,0BACX;IAAU,QAAQ;IAAS;;;;;EAoBxB,QACF,OAAO,eACP,UAAU,0BACX,QAAQ;;;;EAcL,OACF,OAAO,eACP,UAAU,2BACX,QAAQ;;;;EAeL,YACF,OAAO,wBACP,UAAU,2BACX,QAAQ;;;;EAyBL,OACF,OAAO,EAAE,kBAAkB,yBAC3B,UAAU,2BACX,QAAQ;;;;EAmBL,YACF,OAAO,wBACP,UAAU,2BACX,QAAQ;;;;EAkBL,OACF,OAAO,kBACP,UAAU,2BACX,QAAQ;;;;EAkBL,aACF,OAAO,yBACP,UAAU,2BACX,QAAQ;;;;EAyBL,sBACF,OAAO,4BACP,UAAU,0BACX,QAAQ;;;;EAaL,UACF,OAAO,EAAE,kBAAkB,6BAC3B,UAAU,2BACX,QAAQ;;;;EAgBL,eACF,OAAO,qBACP,UAAU,2BACX,QAAQ;;;;EAgBL,WACF,OAAO,EAAE,kBAAkB,6BAC3B,UAAU,0BACX,QAAQ;;;;EAeX,UAAU,OAAO"}