@polyester/sdk 0.4.0 → 0.4.1

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

@@ -1,7 +1,7 @@
-import { validation_d_exports } from "../../shared/validation.js";
 import { HeatmapDepth, HeatmapInterval, HeatmapQuantityMode } from "../../gen/marketdata/v1/heatmap_pb.js";
 import { DecodedEnum } from "../../utils/types.js";
 import { SdkScales } from "../../shared/decimal-surface.js";
+import * as v from "valibot";
 //#region src/services/heatmap/heatmap.schemas.d.ts
 type HeatmapTimeRangeInit = {
   startTime?: TimestampInit;
@@ -11,16 +11,16 @@ type TimestampInit = {
   seconds: bigint;
   nanos: number;
 };
-declare const GetOrderbookHeatmapInputSchema: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.ObjectSchema<{
-  readonly symbolId: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.NumberSchema<undefined>, validation_d_exports.IntegerAction<number, undefined>, validation_d_exports.GtValueAction<number, 0, undefined>]>;
-  readonly interval: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.OptionalSchema<validation_d_exports.PicklistSchema<readonly ["1s", "1m", "5m", "1h"], undefined>, "1s">, validation_d_exports.TransformAction<"1h" | "1m" | "1s" | "5m", HeatmapInterval>]>;
-  readonly depth: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.OptionalSchema<validation_d_exports.PicklistSchema<readonly [1, 5, 10, 20, 50, 100, 200, 500, 1000], undefined>, 50>, validation_d_exports.TransformAction<5 | 10 | 20 | 1 | 200 | 500 | 50 | 100 | 1000, HeatmapDepth>]>;
-  readonly quantityMode: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.OptionalSchema<validation_d_exports.PicklistSchema<readonly ["close", "peak"], undefined>, "close">, validation_d_exports.TransformAction<"close" | "peak", HeatmapQuantityMode>]>;
-  readonly limit: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.NumberSchema<undefined>, validation_d_exports.IntegerAction<number, undefined>, validation_d_exports.GtValueAction<number, 0, undefined>, validation_d_exports.MaxValueAction<number, 20000, undefined>]>;
-  readonly startTsSec: validation_d_exports.OptionalSchema<validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.NumberSchema<undefined>, validation_d_exports.IntegerAction<number, undefined>, validation_d_exports.MinValueAction<number, 0, undefined>, validation_d_exports.MaxValueAction<number, number, undefined>, validation_d_exports.TransformAction<number, bigint>]>, undefined>;
-  readonly endTsSec: validation_d_exports.OptionalSchema<validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.NumberSchema<undefined>, validation_d_exports.IntegerAction<number, undefined>, validation_d_exports.MinValueAction<number, 0, undefined>, validation_d_exports.MaxValueAction<number, number, undefined>, validation_d_exports.TransformAction<number, bigint>]>, undefined>;
-  readonly pageToken: validation_d_exports.OptionalSchema<validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.StringSchema<undefined>, validation_d_exports.TrimAction]>, "">;
-}, undefined>, validation_d_exports.CheckAction<{
+declare const GetOrderbookHeatmapInputSchema: v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly symbolId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.GtValueAction<number, 0, undefined>]>;
+  readonly interval: v.SchemaWithPipe<readonly [v.OptionalSchema<v.PicklistSchema<readonly ["1s", "1m", "5m", "1h"], undefined>, "1s">, v.TransformAction<"1h" | "1m" | "1s" | "5m", HeatmapInterval>]>;
+  readonly depth: v.SchemaWithPipe<readonly [v.OptionalSchema<v.PicklistSchema<readonly [1, 5, 10, 20, 50, 100, 200, 500, 1000], undefined>, 50>, v.TransformAction<5 | 10 | 20 | 1 | 200 | 500 | 50 | 1000 | 100, HeatmapDepth>]>;
+  readonly quantityMode: v.SchemaWithPipe<readonly [v.OptionalSchema<v.PicklistSchema<readonly ["close", "peak"], undefined>, "close">, v.TransformAction<"close" | "peak", HeatmapQuantityMode>]>;
+  readonly limit: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.GtValueAction<number, 0, undefined>, v.MaxValueAction<number, 20000, undefined>]>;
+  readonly startTsSec: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.TransformAction<number, bigint>]>, undefined>;
+  readonly endTsSec: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>, v.TransformAction<number, bigint>]>, undefined>;
+  readonly pageToken: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, "">;
+}, undefined>, v.CheckAction<{
   symbolId: number;
   interval: HeatmapInterval;
   depth: HeatmapDepth;
@@ -29,7 +29,7 @@ declare const GetOrderbookHeatmapInputSchema: validation_d_exports.SchemaWithPip
   startTsSec?: bigint | undefined;
   endTsSec?: bigint | undefined;
   pageToken: string;
-}, "pageToken, startTsSec, or endTsSec is required">, validation_d_exports.TransformAction<{
+}, "pageToken, startTsSec, or endTsSec is required">, v.TransformAction<{
   symbolId: number;
   interval: HeatmapInterval;
   depth: HeatmapDepth;
@@ -47,33 +47,33 @@ declare const GetOrderbookHeatmapInputSchema: validation_d_exports.SchemaWithPip
   pageToken: string;
   timeRange: HeatmapTimeRangeInit | undefined;
 }>]>;
-declare const OrderbookHeatmapLevelsRawSchema: validation_d_exports.ObjectSchema<{
-  readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-  readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+declare const OrderbookHeatmapLevelsRawSchema: v.ObjectSchema<{
+  readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+  readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
 }, undefined>;
-type OrderbookHeatmapLevelsRaw = validation_d_exports.InferOutput<typeof OrderbookHeatmapLevelsRawSchema>;
+type OrderbookHeatmapLevelsRaw = v.InferOutput<typeof OrderbookHeatmapLevelsRawSchema>;
 declare function convertHeatmapLevels(levels: OrderbookHeatmapLevelsRaw, priceScale: number, qtyScale: number): {
   price: string[];
   qty: string[];
 };
 type OrderbookHeatmapLevels = ReturnType<typeof convertHeatmapLevels>;
 type OrderbookHeatmapDeltaLevels = OrderbookHeatmapLevels;
-declare const OrderbookHeatmapKeyframeRawSchema: validation_d_exports.ObjectSchema<{
-  readonly tsSec: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, number>]>;
-  readonly bestBidTicks: validation_d_exports.BigintSchema<undefined>;
-  readonly bestAskTicks: validation_d_exports.BigintSchema<undefined>;
-  readonly midTicks: validation_d_exports.BigintSchema<undefined>;
-  readonly bids: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-    readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-    readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+declare const OrderbookHeatmapKeyframeRawSchema: v.ObjectSchema<{
+  readonly tsSec: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
+  readonly bestBidTicks: v.BigintSchema<undefined>;
+  readonly bestAskTicks: v.BigintSchema<undefined>;
+  readonly midTicks: v.BigintSchema<undefined>;
+  readonly bids: v.OptionalSchema<v.ObjectSchema<{
+    readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+    readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
   }, undefined>, undefined>;
-  readonly asks: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-    readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-    readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+  readonly asks: v.OptionalSchema<v.ObjectSchema<{
+    readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+    readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
   }, undefined>, undefined>;
-  readonly bookSeq: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
+  readonly bookSeq: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
 }, undefined>;
-type OrderbookHeatmapKeyframeRaw = validation_d_exports.InferOutput<typeof OrderbookHeatmapKeyframeRawSchema>;
+type OrderbookHeatmapKeyframeRaw = v.InferOutput<typeof OrderbookHeatmapKeyframeRawSchema>;
 declare function convertHeatmapKeyframe(keyframe: OrderbookHeatmapKeyframeRaw, priceScale: number, qtyScale: number): {
   tsSec: number;
   bestBid: string;
@@ -90,21 +90,21 @@ declare function convertHeatmapKeyframe(keyframe: OrderbookHeatmapKeyframeRaw, p
   bookSeq: string;
 };
 type OrderbookHeatmapKeyframe = ReturnType<typeof convertHeatmapKeyframe>;
-declare const OrderbookHeatmapDeltaBucketRawSchema: validation_d_exports.ObjectSchema<{
-  readonly tsSec: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, number>]>;
-  readonly bids: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-    readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-    readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+declare const OrderbookHeatmapDeltaBucketRawSchema: v.ObjectSchema<{
+  readonly tsSec: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
+  readonly bids: v.OptionalSchema<v.ObjectSchema<{
+    readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+    readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
   }, undefined>, undefined>;
-  readonly asks: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-    readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-    readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+  readonly asks: v.OptionalSchema<v.ObjectSchema<{
+    readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+    readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
   }, undefined>, undefined>;
-  readonly updatesInBucket: validation_d_exports.NumberSchema<undefined>;
-  readonly bookSeqStart: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
-  readonly bookSeqEnd: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
+  readonly updatesInBucket: v.NumberSchema<undefined>;
+  readonly bookSeqStart: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+  readonly bookSeqEnd: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
 }, undefined>;
-type OrderbookHeatmapDeltaBucketRaw = validation_d_exports.InferOutput<typeof OrderbookHeatmapDeltaBucketRawSchema>;
+type OrderbookHeatmapDeltaBucketRaw = v.InferOutput<typeof OrderbookHeatmapDeltaBucketRawSchema>;
 declare function convertHeatmapDeltaBucket(bucket: OrderbookHeatmapDeltaBucketRaw, priceScale: number, qtyScale: number): {
   tsSec: number;
   bids: {
@@ -120,26 +120,26 @@ declare function convertHeatmapDeltaBucket(bucket: OrderbookHeatmapDeltaBucketRa
   bookSeqEnd: string;
 };
 type OrderbookHeatmapDeltaBucket = ReturnType<typeof convertHeatmapDeltaBucket>;
-declare const OrderbookHeatmapLiveBucketRawSchema: validation_d_exports.ObjectSchema<{
-  readonly symbolId: validation_d_exports.NumberSchema<undefined>;
-  readonly interval: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.NumberSchema<undefined>, validation_d_exports.TransformAction<number, DecodedEnum<"1h" | "1m" | "1s" | "5m">>]>;
-  readonly tsSec: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, number>]>;
-  readonly isFinal: validation_d_exports.BooleanSchema<undefined>;
-  readonly bids: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-    readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-    readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+declare const OrderbookHeatmapLiveBucketRawSchema: v.ObjectSchema<{
+  readonly symbolId: v.NumberSchema<undefined>;
+  readonly interval: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, DecodedEnum<"1h" | "1m" | "1s" | "5m">>]>;
+  readonly tsSec: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
+  readonly isFinal: v.BooleanSchema<undefined>;
+  readonly bids: v.OptionalSchema<v.ObjectSchema<{
+    readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+    readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
   }, undefined>, undefined>;
-  readonly asks: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-    readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-    readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+  readonly asks: v.OptionalSchema<v.ObjectSchema<{
+    readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+    readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
   }, undefined>, undefined>;
-  readonly updatesInBucket: validation_d_exports.NumberSchema<undefined>;
-  readonly bookSeqStart: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
-  readonly bookSeqEnd: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
-  readonly quantityMode: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.NumberSchema<undefined>, validation_d_exports.TransformAction<number, DecodedEnum<"close" | "peak">>]>;
-  readonly effectiveBinTicks: validation_d_exports.BigintSchema<undefined>;
+  readonly updatesInBucket: v.NumberSchema<undefined>;
+  readonly bookSeqStart: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+  readonly bookSeqEnd: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+  readonly quantityMode: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, DecodedEnum<"close" | "peak">>]>;
+  readonly effectiveBinTicks: v.BigintSchema<undefined>;
 }, undefined>;
-type OrderbookHeatmapLiveBucketRaw = validation_d_exports.InferOutput<typeof OrderbookHeatmapLiveBucketRawSchema>;
+type OrderbookHeatmapLiveBucketRaw = v.InferOutput<typeof OrderbookHeatmapLiveBucketRawSchema>;
 declare function convertHeatmapLiveBucket(bucket: OrderbookHeatmapLiveBucketRaw, scales: SdkScales): {
   symbolId: number;
   interval: DecodedEnum<"1h" | "1m" | "1s" | "5m">;
@@ -160,38 +160,38 @@ declare function convertHeatmapLiveBucket(bucket: OrderbookHeatmapLiveBucketRaw,
   effectiveBinSize: string;
 };
 type OrderbookHeatmapLiveBucket = ReturnType<typeof convertHeatmapLiveBucket>;
-declare const OrderbookHeatmapDeltaChainRawSchema: validation_d_exports.ObjectSchema<{
-  readonly baseKeyframe: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-    readonly tsSec: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, number>]>;
-    readonly bestBidTicks: validation_d_exports.BigintSchema<undefined>;
-    readonly bestAskTicks: validation_d_exports.BigintSchema<undefined>;
-    readonly midTicks: validation_d_exports.BigintSchema<undefined>;
-    readonly bids: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-      readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-      readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+declare const OrderbookHeatmapDeltaChainRawSchema: v.ObjectSchema<{
+  readonly baseKeyframe: v.OptionalSchema<v.ObjectSchema<{
+    readonly tsSec: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
+    readonly bestBidTicks: v.BigintSchema<undefined>;
+    readonly bestAskTicks: v.BigintSchema<undefined>;
+    readonly midTicks: v.BigintSchema<undefined>;
+    readonly bids: v.OptionalSchema<v.ObjectSchema<{
+      readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+      readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
     }, undefined>, undefined>;
-    readonly asks: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-      readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-      readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+    readonly asks: v.OptionalSchema<v.ObjectSchema<{
+      readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+      readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
     }, undefined>, undefined>;
-    readonly bookSeq: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
+    readonly bookSeq: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
   }, undefined>, undefined>;
-  readonly deltas: validation_d_exports.OptionalSchema<validation_d_exports.ArraySchema<validation_d_exports.ObjectSchema<{
-    readonly tsSec: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, number>]>;
-    readonly bids: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-      readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-      readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+  readonly deltas: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+    readonly tsSec: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
+    readonly bids: v.OptionalSchema<v.ObjectSchema<{
+      readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+      readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
     }, undefined>, undefined>;
-    readonly asks: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-      readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-      readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+    readonly asks: v.OptionalSchema<v.ObjectSchema<{
+      readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+      readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
     }, undefined>, undefined>;
-    readonly updatesInBucket: validation_d_exports.NumberSchema<undefined>;
-    readonly bookSeqStart: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
-    readonly bookSeqEnd: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
+    readonly updatesInBucket: v.NumberSchema<undefined>;
+    readonly bookSeqStart: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+    readonly bookSeqEnd: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
   }, undefined>, undefined>, readonly []>;
 }, undefined>;
-type OrderbookHeatmapDeltaChainRaw = validation_d_exports.InferOutput<typeof OrderbookHeatmapDeltaChainRawSchema>;
+type OrderbookHeatmapDeltaChainRaw = v.InferOutput<typeof OrderbookHeatmapDeltaChainRawSchema>;
 declare function convertHeatmapDeltaChain(chain: OrderbookHeatmapDeltaChainRaw, priceScale: number, qtyScale: number): {
   baseKeyframe: {
     tsSec: number;
@@ -224,70 +224,70 @@ declare function convertHeatmapDeltaChain(chain: OrderbookHeatmapDeltaChainRaw,
   }[];
 };
 type OrderbookHeatmapDeltaChain = ReturnType<typeof convertHeatmapDeltaChain>;
-declare function createOrderbookHeatmapResponseSchema(scales: SdkScales): validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.ObjectSchema<{
-  readonly symbolId: validation_d_exports.NumberSchema<undefined>;
-  readonly interval: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.NumberSchema<undefined>, validation_d_exports.TransformAction<number, DecodedEnum<"1h" | "1m" | "1s" | "5m">>]>;
-  readonly depth: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.NumberSchema<undefined>, validation_d_exports.TransformAction<number, 5 | 10 | 20 | 1 | "unspecified" | 200 | 500 | 50 | 100 | 1000>]>;
-  readonly chain: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-    readonly baseKeyframe: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-      readonly tsSec: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, number>]>;
-      readonly bestBidTicks: validation_d_exports.BigintSchema<undefined>;
-      readonly bestAskTicks: validation_d_exports.BigintSchema<undefined>;
-      readonly midTicks: validation_d_exports.BigintSchema<undefined>;
-      readonly bids: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-        readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-        readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+declare function createOrderbookHeatmapResponseSchema(scales: SdkScales): v.SchemaWithPipe<readonly [v.ObjectSchema<{
+  readonly symbolId: v.NumberSchema<undefined>;
+  readonly interval: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, DecodedEnum<"1h" | "1m" | "1s" | "5m">>]>;
+  readonly depth: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, 5 | 10 | 20 | 1 | "unspecified" | 200 | 500 | 50 | 1000 | 100>]>;
+  readonly chain: v.OptionalSchema<v.ObjectSchema<{
+    readonly baseKeyframe: v.OptionalSchema<v.ObjectSchema<{
+      readonly tsSec: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
+      readonly bestBidTicks: v.BigintSchema<undefined>;
+      readonly bestAskTicks: v.BigintSchema<undefined>;
+      readonly midTicks: v.BigintSchema<undefined>;
+      readonly bids: v.OptionalSchema<v.ObjectSchema<{
+        readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+        readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
       }, undefined>, undefined>;
-      readonly asks: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-        readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-        readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+      readonly asks: v.OptionalSchema<v.ObjectSchema<{
+        readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+        readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
       }, undefined>, undefined>;
-      readonly bookSeq: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
+      readonly bookSeq: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
     }, undefined>, undefined>;
-    readonly deltas: validation_d_exports.OptionalSchema<validation_d_exports.ArraySchema<validation_d_exports.ObjectSchema<{
-      readonly tsSec: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, number>]>;
-      readonly bids: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-        readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-        readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+    readonly deltas: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly tsSec: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
+      readonly bids: v.OptionalSchema<v.ObjectSchema<{
+        readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+        readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
       }, undefined>, undefined>;
-      readonly asks: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-        readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-        readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+      readonly asks: v.OptionalSchema<v.ObjectSchema<{
+        readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+        readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
       }, undefined>, undefined>;
-      readonly updatesInBucket: validation_d_exports.NumberSchema<undefined>;
-      readonly bookSeqStart: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
-      readonly bookSeqEnd: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
+      readonly updatesInBucket: v.NumberSchema<undefined>;
+      readonly bookSeqStart: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+      readonly bookSeqEnd: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
     }, undefined>, undefined>, readonly []>;
   }, undefined>, undefined>;
-  readonly lastPersistedTsSec: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, number>]>;
-  readonly liveFromBookSeqEnd: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
-  readonly hasLiveAnchor: validation_d_exports.BooleanSchema<undefined>;
-  readonly nextPageToken: validation_d_exports.OptionalSchema<validation_d_exports.StringSchema<undefined>, "">;
-  readonly serverTimeSec: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, number>]>;
-  readonly quantityMode: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.NumberSchema<undefined>, validation_d_exports.TransformAction<number, DecodedEnum<"close" | "peak">>]>;
-  readonly liveBucket: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-    readonly symbolId: validation_d_exports.NumberSchema<undefined>;
-    readonly interval: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.NumberSchema<undefined>, validation_d_exports.TransformAction<number, DecodedEnum<"1h" | "1m" | "1s" | "5m">>]>;
-    readonly tsSec: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, number>]>;
-    readonly isFinal: validation_d_exports.BooleanSchema<undefined>;
-    readonly bids: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-      readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-      readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+  readonly lastPersistedTsSec: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
+  readonly liveFromBookSeqEnd: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+  readonly hasLiveAnchor: v.BooleanSchema<undefined>;
+  readonly nextPageToken: v.OptionalSchema<v.StringSchema<undefined>, "">;
+  readonly serverTimeSec: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
+  readonly quantityMode: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, DecodedEnum<"close" | "peak">>]>;
+  readonly liveBucket: v.OptionalSchema<v.ObjectSchema<{
+    readonly symbolId: v.NumberSchema<undefined>;
+    readonly interval: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, DecodedEnum<"1h" | "1m" | "1s" | "5m">>]>;
+    readonly tsSec: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, number>]>;
+    readonly isFinal: v.BooleanSchema<undefined>;
+    readonly bids: v.OptionalSchema<v.ObjectSchema<{
+      readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+      readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
     }, undefined>, undefined>;
-    readonly asks: validation_d_exports.OptionalSchema<validation_d_exports.ObjectSchema<{
-      readonly priceTicks: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
-      readonly qtyScaled: validation_d_exports.ArraySchema<validation_d_exports.BigintSchema<undefined>, undefined>;
+    readonly asks: v.OptionalSchema<v.ObjectSchema<{
+      readonly priceTicks: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
+      readonly qtyScaled: v.ArraySchema<v.BigintSchema<undefined>, undefined>;
     }, undefined>, undefined>;
-    readonly updatesInBucket: validation_d_exports.NumberSchema<undefined>;
-    readonly bookSeqStart: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
-    readonly bookSeqEnd: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.BigintSchema<undefined>, validation_d_exports.TransformAction<bigint, string>]>;
-    readonly quantityMode: validation_d_exports.SchemaWithPipe<readonly [validation_d_exports.NumberSchema<undefined>, validation_d_exports.TransformAction<number, DecodedEnum<"close" | "peak">>]>;
-    readonly effectiveBinTicks: validation_d_exports.BigintSchema<undefined>;
+    readonly updatesInBucket: v.NumberSchema<undefined>;
+    readonly bookSeqStart: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+    readonly bookSeqEnd: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+    readonly quantityMode: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.TransformAction<number, DecodedEnum<"close" | "peak">>]>;
+    readonly effectiveBinTicks: v.BigintSchema<undefined>;
   }, undefined>, undefined>;
-}, undefined>, validation_d_exports.TransformAction<{
+}, undefined>, v.TransformAction<{
   symbolId: number;
   interval: DecodedEnum<"1h" | "1m" | "1s" | "5m">;
-  depth: 5 | 10 | 20 | 1 | "unspecified" | 200 | 500 | 50 | 100 | 1000;
+  depth: 5 | 10 | 20 | 1 | "unspecified" | 200 | 500 | 50 | 1000 | 100;
   chain?: {
     baseKeyframe?: {
       tsSec: number;
@@ -347,7 +347,7 @@ declare function createOrderbookHeatmapResponseSchema(scales: SdkScales): valida
 }, {
   symbolId: number;
   interval: DecodedEnum<"1h" | "1m" | "1s" | "5m">;
-  depth: 5 | 10 | 20 | 1 | "unspecified" | 200 | 500 | 50 | 100 | 1000;
+  depth: 5 | 10 | 20 | 1 | "unspecified" | 200 | 500 | 50 | 1000 | 100;
   chain: {
     baseKeyframe: {
       tsSec: number;
@@ -405,8 +405,8 @@ declare function createOrderbookHeatmapResponseSchema(scales: SdkScales): valida
     effectiveBinSize: string;
   } | undefined;
 }>]>;
-type GetOrderbookHeatmapInput = validation_d_exports.InferInput<typeof GetOrderbookHeatmapInputSchema>;
-type OrderbookHeatmapResponse = validation_d_exports.InferOutput<ReturnType<typeof createOrderbookHeatmapResponseSchema>>;
+type GetOrderbookHeatmapInput = v.InferInput<typeof GetOrderbookHeatmapInputSchema>;
+type OrderbookHeatmapResponse = v.InferOutput<ReturnType<typeof createOrderbookHeatmapResponseSchema>>;
 //#endregion
 export { GetOrderbookHeatmapInput, GetOrderbookHeatmapInputSchema, OrderbookHeatmapDeltaBucket, OrderbookHeatmapDeltaChain, OrderbookHeatmapDeltaLevels, OrderbookHeatmapKeyframe, OrderbookHeatmapLevels, OrderbookHeatmapLiveBucket, OrderbookHeatmapResponse, createOrderbookHeatmapResponseSchema };
 //# sourceMappingURL=heatmap.schemas.d.ts.map

package/dist/services/heatmap/heatmap.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heatmap.schemas.d.ts","names":[],"sources":["../../../src/services/heatmap/heatmap.schemas.ts"],"mappings":";;;;;KAqBK;EACD,YAAY;EACZ,UAAU;;KAGT;EAAkB;EAAiB;;cAqB3B,gCAA8B,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoErC,iCAA+B,qBAAA;;;;KAKhC,4BAA4B,qBAAE,mBAAmB;iBAE7C,qBACL,QAAQ,2BACR,oBACA;;;;KAQQ,yBAAyB,kBAAkB;KAE3C,8BAA8B;cAEpC,mCAAiC,qBAAA;;;;;;;;;;;;;;;KAUlC,8BAA8B,qBAAE,mBAAmB;iBAE/C,uBACL,UAAU,6BACV,oBACA;;;;;;;;;;;;;;;KAaQ,2BAA2B,kBAAkB;cAEnD,sCAAoC,qBAAA;;;;;;;;;;;;;;KASrC,iCAAiC,qBAAE,mBAAmB;iBAElD,0BACL,QAAQ,gCACR,oBACA;;;;;;;;;;;;;;KAYQ,8BAA8B,kBAAkB;cAEtD,qCAAmC,qBAAA;;;;;;;;;;;;;;;;;;;KAcpC,gCAAgC,qBAAE,mBAAmB;iBAEjD,yBAAyB,QAAQ,+BAA+B,QAAQ;;;;;;;;;;;;;;;;;;;KAkBrE,6BAA6B,kBAAkB;cASrD,qCAAmC,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKpC,gCAAgC,qBAAE,mBAAmB;iBAEjD,yBACL,OAAO,+BACP,oBACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAYQ,6BAA6B,kBAAkB;iBA0B3C,qCAAqC,QAAQ,YAAS,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2B1D,2BAA2B,qBAAE,kBAAkB;KAE/C,2BAA2B,qBAAE,YACrC,kBAAkB"}
+{"version":3,"file":"heatmap.schemas.d.ts","names":[],"sources":["../../../src/services/heatmap/heatmap.schemas.ts"],"mappings":";;;;;KAqBK;EACD,YAAY;EACZ,UAAU;;KAGT;EAAkB;EAAiB;;cAqB3B,gCAA8B,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoErC,iCAA+B,EAAA;;;;KAKhC,4BAA4B,EAAE,mBAAmB;iBAE7C,qBACL,QAAQ,2BACR,oBACA;;;;KAQQ,yBAAyB,kBAAkB;KAE3C,8BAA8B;cAEpC,mCAAiC,EAAA;;;;;;;;;;;;;;;KAUlC,8BAA8B,EAAE,mBAAmB;iBAE/C,uBACL,UAAU,6BACV,oBACA;;;;;;;;;;;;;;;KAaQ,2BAA2B,kBAAkB;cAEnD,sCAAoC,EAAA;;;;;;;;;;;;;;KASrC,iCAAiC,EAAE,mBAAmB;iBAElD,0BACL,QAAQ,gCACR,oBACA;;;;;;;;;;;;;;KAYQ,8BAA8B,kBAAkB;cAEtD,qCAAmC,EAAA;;;;;;;;;;;;;;;;;;;KAcpC,gCAAgC,EAAE,mBAAmB;iBAEjD,yBAAyB,QAAQ,+BAA+B,QAAQ;;;;;;;;;;;;;;;;;;;KAkBrE,6BAA6B,kBAAkB;cASrD,qCAAmC,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKpC,gCAAgC,EAAE,mBAAmB;iBAEjD,yBACL,OAAO,+BACP,oBACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAYQ,6BAA6B,kBAAkB;iBA0B3C,qCAAqC,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2B1D,2BAA2B,EAAE,kBAAkB;KAE/C,2BAA2B,EAAE,YACrC,kBAAkB"}

package/dist/services/heatmap/heatmap.schemas.js

@@ -1,28 +1,28 @@
-import { validation_exports } from "../../shared/validation.js";
 import { requiredEnumLabel } from "../../shared/proto-enum-codec.js";
 import { OptionalTimestampSecondsInputSchema } from "../../shared/schemas.js";
 import { scaledToDecimalOutput } from "../../shared/decimal-surface.js";
 import { HEATMAP_DEPTH_VALUES, HEATMAP_INTERVAL_VALUES, HEATMAP_QUANTITY_MODE_VALUES, HeatmapDepthCodec, HeatmapIntervalCodec, HeatmapQuantityModeCodec } from "./heatmap.codecs.js";
+import * as v from "valibot";
 //#region src/services/heatmap/heatmap.schemas.ts
-const IntervalInputSchema = validation_exports.pipe(validation_exports.optional(validation_exports.picklist(HEATMAP_INTERVAL_VALUES), "1s"), validation_exports.transform((value) => HeatmapIntervalCodec.inputToProto[value]));
-const DepthInputSchema = validation_exports.pipe(validation_exports.optional(validation_exports.picklist(HEATMAP_DEPTH_VALUES), 50), validation_exports.transform((value) => HeatmapDepthCodec.inputToProto[value]));
-const QuantityModeInputSchema = validation_exports.pipe(validation_exports.optional(validation_exports.picklist(HEATMAP_QUANTITY_MODE_VALUES), "close"), validation_exports.transform((value) => HeatmapQuantityModeCodec.inputToProto[value]));
+const IntervalInputSchema = v.pipe(v.optional(v.picklist(HEATMAP_INTERVAL_VALUES), "1s"), v.transform((value) => HeatmapIntervalCodec.inputToProto[value]));
+const DepthInputSchema = v.pipe(v.optional(v.picklist(HEATMAP_DEPTH_VALUES), 50), v.transform((value) => HeatmapDepthCodec.inputToProto[value]));
+const QuantityModeInputSchema = v.pipe(v.optional(v.picklist(HEATMAP_QUANTITY_MODE_VALUES), "close"), v.transform((value) => HeatmapQuantityModeCodec.inputToProto[value]));
 function timestampFromTsSec(tsSec) {
 	return {
 		seconds: tsSec,
 		nanos: 0
 	};
 }
-const GetOrderbookHeatmapInputSchema = validation_exports.pipe(validation_exports.object({
-	symbolId: validation_exports.pipe(validation_exports.number(), validation_exports.integer(), validation_exports.gtValue(0)),
+const GetOrderbookHeatmapInputSchema = v.pipe(v.object({
+	symbolId: v.pipe(v.number(), v.integer(), v.gtValue(0)),
 	interval: IntervalInputSchema,
 	depth: DepthInputSchema,
 	quantityMode: QuantityModeInputSchema,
-	limit: validation_exports.pipe(validation_exports.number(), validation_exports.integer(), validation_exports.gtValue(0), validation_exports.maxValue(2e4)),
+	limit: v.pipe(v.number(), v.integer(), v.gtValue(0), v.maxValue(2e4)),
 	startTsSec: OptionalTimestampSecondsInputSchema,
 	endTsSec: OptionalTimestampSecondsInputSchema,
-	pageToken: validation_exports.optional(validation_exports.pipe(validation_exports.string(), validation_exports.trim()), "")
-}), validation_exports.check((value) => value.pageToken !== "" || value.startTsSec != null || value.endTsSec != null, "pageToken, startTsSec, or endTsSec is required"), validation_exports.transform((value) => {
+	pageToken: v.optional(v.pipe(v.string(), v.trim()), "")
+}), v.check((value) => value.pageToken !== "" || value.startTsSec != null || value.endTsSec != null, "pageToken, startTsSec, or endTsSec is required"), v.transform((value) => {
 	const timeRange = value.pageToken !== "" ? void 0 : {
 		startTime: value.startTsSec != null ? timestampFromTsSec(value.startTsSec) : void 0,
 		endTime: value.endTsSec != null ? timestampFromTsSec(value.endTsSec) : void 0
@@ -43,11 +43,11 @@ function requiredIntervalLabelFor(value) {
 function requiredQuantityModeLabelFor(value) {
 	return requiredEnumLabel(HeatmapQuantityModeCodec.protoToOutput, value, "OrderbookHeatmapResponseSchema", "quantity mode");
 }
-const TimestampSecondsSchema = validation_exports.pipe(validation_exports.bigint(), validation_exports.transform((value) => Number(value)));
-const Uint64StringSchema = validation_exports.pipe(validation_exports.bigint(), validation_exports.transform((value) => value.toString()));
-const OrderbookHeatmapLevelsRawSchema = validation_exports.object({
-	priceTicks: validation_exports.array(validation_exports.bigint()),
-	qtyScaled: validation_exports.array(validation_exports.bigint())
+const TimestampSecondsSchema = v.pipe(v.bigint(), v.transform((value) => Number(value)));
+const Uint64StringSchema = v.pipe(v.bigint(), v.transform((value) => value.toString()));
+const OrderbookHeatmapLevelsRawSchema = v.object({
+	priceTicks: v.array(v.bigint()),
+	qtyScaled: v.array(v.bigint())
 });
 function convertHeatmapLevels(levels, priceScale, qtyScale) {
 	return {
@@ -55,13 +55,13 @@ function convertHeatmapLevels(levels, priceScale, qtyScale) {
 		qty: levels.qtyScaled.map((qty) => scaledToDecimalOutput(qty, qtyScale))
 	};
 }
-const OrderbookHeatmapKeyframeRawSchema = validation_exports.object({
+const OrderbookHeatmapKeyframeRawSchema = v.object({
 	tsSec: TimestampSecondsSchema,
-	bestBidTicks: validation_exports.bigint(),
-	bestAskTicks: validation_exports.bigint(),
-	midTicks: validation_exports.bigint(),
-	bids: validation_exports.optional(OrderbookHeatmapLevelsRawSchema),
-	asks: validation_exports.optional(OrderbookHeatmapLevelsRawSchema),
+	bestBidTicks: v.bigint(),
+	bestAskTicks: v.bigint(),
+	midTicks: v.bigint(),
+	bids: v.optional(OrderbookHeatmapLevelsRawSchema),
+	asks: v.optional(OrderbookHeatmapLevelsRawSchema),
 	bookSeq: Uint64StringSchema
 });
 function convertHeatmapKeyframe(keyframe, priceScale, qtyScale) {
@@ -75,11 +75,11 @@ function convertHeatmapKeyframe(keyframe, priceScale, qtyScale) {
 		bookSeq: keyframe.bookSeq
 	};
 }
-const OrderbookHeatmapDeltaBucketRawSchema = validation_exports.object({
+const OrderbookHeatmapDeltaBucketRawSchema = v.object({
 	tsSec: TimestampSecondsSchema,
-	bids: validation_exports.optional(OrderbookHeatmapLevelsRawSchema),
-	asks: validation_exports.optional(OrderbookHeatmapLevelsRawSchema),
-	updatesInBucket: validation_exports.number(),
+	bids: v.optional(OrderbookHeatmapLevelsRawSchema),
+	asks: v.optional(OrderbookHeatmapLevelsRawSchema),
+	updatesInBucket: v.number(),
 	bookSeqStart: Uint64StringSchema,
 	bookSeqEnd: Uint64StringSchema
 });
@@ -93,18 +93,18 @@ function convertHeatmapDeltaBucket(bucket, priceScale, qtyScale) {
 		bookSeqEnd: bucket.bookSeqEnd
 	};
 }
-const OrderbookHeatmapLiveBucketRawSchema = validation_exports.object({
-	symbolId: validation_exports.number(),
-	interval: validation_exports.pipe(validation_exports.number(), validation_exports.transform(requiredIntervalLabelFor)),
+const OrderbookHeatmapLiveBucketRawSchema = v.object({
+	symbolId: v.number(),
+	interval: v.pipe(v.number(), v.transform(requiredIntervalLabelFor)),
 	tsSec: TimestampSecondsSchema,
-	isFinal: validation_exports.boolean(),
-	bids: validation_exports.optional(OrderbookHeatmapLevelsRawSchema),
-	asks: validation_exports.optional(OrderbookHeatmapLevelsRawSchema),
-	updatesInBucket: validation_exports.number(),
+	isFinal: v.boolean(),
+	bids: v.optional(OrderbookHeatmapLevelsRawSchema),
+	asks: v.optional(OrderbookHeatmapLevelsRawSchema),
+	updatesInBucket: v.number(),
 	bookSeqStart: Uint64StringSchema,
 	bookSeqEnd: Uint64StringSchema,
-	quantityMode: validation_exports.pipe(validation_exports.number(), validation_exports.transform(requiredQuantityModeLabelFor)),
-	effectiveBinTicks: validation_exports.bigint()
+	quantityMode: v.pipe(v.number(), v.transform(requiredQuantityModeLabelFor)),
+	effectiveBinTicks: v.bigint()
 });
 function convertHeatmapLiveBucket(bucket, scales) {
 	const priceScale = scales.price();
@@ -124,11 +124,11 @@ function convertHeatmapLiveBucket(bucket, scales) {
 	};
 }
 function createOrderbookHeatmapLiveBucketSchema(scales) {
-	return validation_exports.pipe(OrderbookHeatmapLiveBucketRawSchema, validation_exports.transform((bucket) => convertHeatmapLiveBucket(bucket, scales)));
+	return v.pipe(OrderbookHeatmapLiveBucketRawSchema, v.transform((bucket) => convertHeatmapLiveBucket(bucket, scales)));
 }
-const OrderbookHeatmapDeltaChainRawSchema = validation_exports.object({
-	baseKeyframe: validation_exports.optional(OrderbookHeatmapKeyframeRawSchema),
-	deltas: validation_exports.optional(validation_exports.array(OrderbookHeatmapDeltaBucketRawSchema), [])
+const OrderbookHeatmapDeltaChainRawSchema = v.object({
+	baseKeyframe: v.optional(OrderbookHeatmapKeyframeRawSchema),
+	deltas: v.optional(v.array(OrderbookHeatmapDeltaBucketRawSchema), [])
 });
 function convertHeatmapDeltaChain(chain, priceScale, qtyScale) {
 	return {
@@ -136,21 +136,21 @@ function convertHeatmapDeltaChain(chain, priceScale, qtyScale) {
 		deltas: chain.deltas.map((bucket) => convertHeatmapDeltaBucket(bucket, priceScale, qtyScale))
 	};
 }
-const OrderbookHeatmapResponseRawSchema = validation_exports.object({
-	symbolId: validation_exports.number(),
-	interval: validation_exports.pipe(validation_exports.number(), validation_exports.transform(requiredIntervalLabelFor)),
-	depth: validation_exports.pipe(validation_exports.number(), validation_exports.transform((value) => requiredEnumLabel(HeatmapDepthCodec.protoToOutput, value, "OrderbookHeatmapResponseSchema", "depth"))),
-	chain: validation_exports.optional(OrderbookHeatmapDeltaChainRawSchema),
+const OrderbookHeatmapResponseRawSchema = v.object({
+	symbolId: v.number(),
+	interval: v.pipe(v.number(), v.transform(requiredIntervalLabelFor)),
+	depth: v.pipe(v.number(), v.transform((value) => requiredEnumLabel(HeatmapDepthCodec.protoToOutput, value, "OrderbookHeatmapResponseSchema", "depth"))),
+	chain: v.optional(OrderbookHeatmapDeltaChainRawSchema),
 	lastPersistedTsSec: TimestampSecondsSchema,
 	liveFromBookSeqEnd: Uint64StringSchema,
-	hasLiveAnchor: validation_exports.boolean(),
-	nextPageToken: validation_exports.optional(validation_exports.string(), ""),
+	hasLiveAnchor: v.boolean(),
+	nextPageToken: v.optional(v.string(), ""),
 	serverTimeSec: TimestampSecondsSchema,
-	quantityMode: validation_exports.pipe(validation_exports.number(), validation_exports.transform(requiredQuantityModeLabelFor)),
-	liveBucket: validation_exports.optional(OrderbookHeatmapLiveBucketRawSchema)
+	quantityMode: v.pipe(v.number(), v.transform(requiredQuantityModeLabelFor)),
+	liveBucket: v.optional(OrderbookHeatmapLiveBucketRawSchema)
 });
 function createOrderbookHeatmapResponseSchema(scales) {
-	return validation_exports.pipe(OrderbookHeatmapResponseRawSchema, validation_exports.transform((res) => {
+	return v.pipe(OrderbookHeatmapResponseRawSchema, v.transform((res) => {
 		const priceScale = scales.price();
 		const qtyScale = scales.baseQty(res.symbolId);
 		return {