@bulletxyz/bullet-sdk 0.16.0-rc.3 → 0.16.1-rc.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (14) hide show
  1. package/dist/browser/index.js +2508 -231
  2. package/dist/browser/index.js.map +4 -4
  3. package/dist/node/index.js +2508 -231
  4. package/dist/node/index.js.map +4 -4
  5. package/dist/types/calc.d.ts +16 -15
  6. package/dist/types/client.d.ts +46 -45
  7. package/dist/types/exchange.d.ts +1 -1
  8. package/dist/types/types.d.ts +4 -3
  9. package/dist/types/utils.d.ts +1 -0
  10. package/dist/types/zod-types/index.d.ts +14 -3
  11. package/dist/types/zod-types/rest.d.ts +1517 -1517
  12. package/dist/types/zod-types/wasm.d.ts +6 -6
  13. package/dist/types/zod-types/ws.d.ts +16 -16
  14. package/package.json +2 -1
package/dist/types/zod-types/rest.d.ts CHANGED
@@ -12,7 +12,7 @@ export declare const StateResponseSchemas: {
12
12
  }> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<{
13
13
  value: z.ZodNullable<T>;
14
14
  }>[k_1]; } : never>;
15
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
15
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
16
16
  }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
17
17
  data: z.ZodObject<{
18
18
  value: z.ZodNullable<T>;
@@ -25,7 +25,7 @@ export declare const StateResponseSchemas: {
25
25
  }> extends infer T_7 ? { [k_1 in keyof T_7]: z.baseObjectInputType<{
26
26
  value: z.ZodNullable<T>;
27
27
  }>[k_1]; } : never>;
28
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
28
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
29
29
  }>, any> extends infer T_3 ? { [k_2 in keyof T_3]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
30
30
  data: z.ZodObject<{
31
31
  value: z.ZodNullable<T>;
@@ -38,7 +38,7 @@ export declare const StateResponseSchemas: {
38
38
  }> extends infer T_5 ? { [k_1 in keyof T_5]: z.baseObjectInputType<{
39
39
  value: z.ZodNullable<T>;
40
40
  }>[k_1]; } : never>;
41
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
41
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
42
42
  }>, any>[k_2]; } : never, z.baseObjectInputType<{
43
43
  data: z.ZodObject<{
44
44
  value: z.ZodNullable<T>;
@@ -51,7 +51,7 @@ export declare const StateResponseSchemas: {
51
51
  }> extends infer T_12 ? { [k_1 in keyof T_12]: z.baseObjectInputType<{
52
52
  value: z.ZodNullable<T>;
53
53
  }>[k_1]; } : never>;
54
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
54
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
55
55
  }> extends infer T_8 ? { [k_3 in keyof T_8]: z.baseObjectInputType<{
56
56
  data: z.ZodObject<{
57
57
  value: z.ZodNullable<T>;
@@ -64,23 +64,23 @@ export declare const StateResponseSchemas: {
64
64
  }> extends infer T_10 ? { [k_1 in keyof T_10]: z.baseObjectInputType<{
65
65
  value: z.ZodNullable<T>;
66
66
  }>[k_1]; } : never>;
67
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
67
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
68
68
  }>[k_3]; } : never>;
69
69
  readonly CustomRouteValue: <T extends z.ZodTypeAny>(valueSchema: T) => z.ZodObject<{
70
70
  data: T;
71
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
71
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
72
72
  }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
73
73
  data: T;
74
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
74
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
75
75
  }>, any> extends infer T_1 ? { [k in keyof T_1]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
76
76
  data: T;
77
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
77
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
78
78
  }>, any>[k]; } : never, z.baseObjectInputType<{
79
79
  data: T;
80
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
80
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
81
81
  }> extends infer T_2 ? { [k_1 in keyof T_2]: z.baseObjectInputType<{
82
82
  data: T;
83
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
83
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
84
84
  }>[k_1]; } : never>;
85
85
  readonly StateMapElement: <K extends z.ZodTypeAny, V extends z.ZodTypeAny>(keySchema: K, valueSchema: V) => z.ZodObject<{
86
86
  data: z.ZodObject<{
@@ -99,7 +99,7 @@ export declare const StateResponseSchemas: {
99
99
  key: K;
100
100
  value: z.ZodNullable<V>;
101
101
  }>[k_1]; } : never>;
102
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
102
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
103
103
  }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
104
104
  data: z.ZodObject<{
105
105
  key: K;
@@ -117,7 +117,7 @@ export declare const StateResponseSchemas: {
117
117
  key: K;
118
118
  value: z.ZodNullable<V>;
119
119
  }>[k_1]; } : never>;
120
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
120
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
121
121
  }>, any> extends infer T_2 ? { [k_2 in keyof T_2]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
122
122
  data: z.ZodObject<{
123
123
  key: K;
@@ -135,7 +135,7 @@ export declare const StateResponseSchemas: {
135
135
  key: K;
136
136
  value: z.ZodNullable<V>;
137
137
  }>[k_1]; } : never>;
138
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
138
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
139
139
  }>, any>[k_2]; } : never, z.baseObjectInputType<{
140
140
  data: z.ZodObject<{
141
141
  key: K;
@@ -153,7 +153,7 @@ export declare const StateResponseSchemas: {
153
153
  key: K;
154
154
  value: z.ZodNullable<V>;
155
155
  }>[k_1]; } : never>;
156
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
156
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
157
157
  }> extends infer T_7 ? { [k_3 in keyof T_7]: z.baseObjectInputType<{
158
158
  data: z.ZodObject<{
159
159
  key: K;
@@ -171,7 +171,7 @@ export declare const StateResponseSchemas: {
171
171
  key: K;
172
172
  value: z.ZodNullable<V>;
173
173
  }>[k_1]; } : never>;
174
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
174
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
175
175
  }>[k_3]; } : never>;
176
176
  readonly StateVecElement: <T extends z.ZodTypeAny>(valueSchema: T) => z.ZodObject<{
177
177
  data: z.ZodObject<{
@@ -190,7 +190,7 @@ export declare const StateResponseSchemas: {
190
190
  index: z.ZodNumber;
191
191
  value: z.ZodNullable<T>;
192
192
  }>[k_1]; } : never>;
193
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
193
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
194
194
  }, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
195
195
  data: z.ZodObject<{
196
196
  index: z.ZodNumber;
@@ -208,7 +208,7 @@ export declare const StateResponseSchemas: {
208
208
  index: z.ZodNumber;
209
209
  value: z.ZodNullable<T>;
210
210
  }>[k_1]; } : never>;
211
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
211
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
212
212
  }>, any> extends infer T_3 ? { [k_2 in keyof T_3]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
213
213
  data: z.ZodObject<{
214
214
  index: z.ZodNumber;
@@ -226,7 +226,7 @@ export declare const StateResponseSchemas: {
226
226
  index: z.ZodNumber;
227
227
  value: z.ZodNullable<T>;
228
228
  }>[k_1]; } : never>;
229
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
229
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
230
230
  }>, any>[k_2]; } : never, z.baseObjectInputType<{
231
231
  data: z.ZodObject<{
232
232
  index: z.ZodNumber;
@@ -244,7 +244,7 @@ export declare const StateResponseSchemas: {
244
244
  index: z.ZodNumber;
245
245
  value: z.ZodNullable<T>;
246
246
  }>[k_1]; } : never>;
247
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
247
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
248
248
  }> extends infer T_8 ? { [k_3 in keyof T_8]: z.baseObjectInputType<{
249
249
  data: z.ZodObject<{
250
250
  index: z.ZodNumber;
@@ -262,13 +262,13 @@ export declare const StateResponseSchemas: {
262
262
  index: z.ZodNumber;
263
263
  value: z.ZodNullable<T>;
264
264
  }>[k_1]; } : never>;
265
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
265
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
266
266
  }>[k_3]; } : never>;
267
267
  };
268
268
  export declare const BaseResponseSchemas: {
269
269
  readonly CoinsResponse: z.ZodObject<{
270
270
  data: z.ZodObject<{
271
- amount: z.ZodEffects<z.ZodBigInt, bigint, bigint>;
271
+ amount: z.ZodBigInt;
272
272
  token_id: z.ZodString;
273
273
  }, "strip", z.ZodTypeAny, {
274
274
  amount: bigint;
@@ -277,13 +277,13 @@ export declare const BaseResponseSchemas: {
277
277
  amount: bigint;
278
278
  token_id: string;
279
279
  }>;
280
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
280
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
281
281
  }, "strip", z.ZodTypeAny, {
282
282
  data: {
283
283
  amount: bigint;
284
284
  token_id: string;
285
285
  };
286
- meta?: Map<any, unknown> | undefined;
286
+ meta?: Map<unknown, unknown> | undefined;
287
287
  }, {
288
288
  data: {
289
289
  amount: bigint;
@@ -302,13 +302,13 @@ export declare const BaseResponseSchemas: {
302
302
  da_height: number;
303
303
  num_txs: number;
304
304
  }>;
305
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
305
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
306
306
  }, "strip", z.ZodTypeAny, {
307
307
  data: {
308
308
  da_height: number;
309
309
  num_txs: number;
310
310
  };
311
- meta?: Map<any, unknown> | undefined;
311
+ meta?: Map<unknown, unknown> | undefined;
312
312
  }, {
313
313
  data: {
314
314
  da_height: number;
@@ -327,13 +327,13 @@ export declare const BaseResponseSchemas: {
327
327
  status: string;
328
328
  id: string;
329
329
  }>;
330
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
330
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
331
331
  }, "strip", z.ZodTypeAny, {
332
332
  data: {
333
333
  status: string;
334
334
  id: string;
335
335
  };
336
- meta?: Map<any, unknown> | undefined;
336
+ meta?: Map<unknown, unknown> | undefined;
337
337
  }, {
338
338
  data: {
339
339
  status: string;
@@ -349,12 +349,12 @@ export declare const BaseResponseSchemas: {
349
349
  }, {
350
350
  nonce: number;
351
351
  }>;
352
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
352
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
353
353
  }, "strip", z.ZodTypeAny, {
354
354
  data: {
355
355
  nonce: number;
356
356
  };
357
- meta?: Map<any, unknown> | undefined;
357
+ meta?: Map<unknown, unknown> | undefined;
358
358
  }, {
359
359
  data: {
360
360
  nonce: number;
@@ -367,913 +367,913 @@ export declare const Schemas: {
367
367
  readonly Order: z.ZodObject<{
368
368
  side: z.ZodEnum<["Bid", "Ask"]>;
369
369
  asset_id: z.ZodNumber;
370
- order_id: z.ZodNumber;
371
- price: z.ZodNumber;
372
- size: z.ZodNumber;
370
+ order_id: z.ZodBigInt;
371
+ price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
372
+ size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
373
373
  reduce_only: z.ZodBoolean;
374
- filled_size: z.ZodNumber;
375
- average_filled_price: z.ZodNumber;
374
+ filled_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
375
+ average_filled_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
376
376
  owner: z.ZodString;
377
- tpsl_order_ids: z.ZodArray<z.ZodNumber, "many">;
377
+ tpsl_order_ids: z.ZodArray<z.ZodBigInt, "many">;
378
378
  }, "strip", z.ZodTypeAny, {
379
- size: number;
380
- price: number;
379
+ size: import("decimal.js").Decimal;
380
+ price: import("decimal.js").Decimal;
381
381
  side: "Bid" | "Ask";
382
- order_id: number;
382
+ order_id: bigint;
383
383
  reduce_only: boolean;
384
384
  asset_id: number;
385
- filled_size: number;
386
- average_filled_price: number;
385
+ filled_size: import("decimal.js").Decimal;
386
+ average_filled_price: import("decimal.js").Decimal;
387
387
  owner: string;
388
- tpsl_order_ids: number[];
388
+ tpsl_order_ids: bigint[];
389
389
  }, {
390
- size: number;
391
- price: number;
390
+ size: string | number;
391
+ price: string | number;
392
392
  side: "Bid" | "Ask";
393
- order_id: number;
393
+ order_id: bigint;
394
394
  reduce_only: boolean;
395
395
  asset_id: number;
396
- filled_size: number;
397
- average_filled_price: number;
396
+ filled_size: string | number;
397
+ average_filled_price: string | number;
398
398
  owner: string;
399
- tpsl_order_ids: number[];
399
+ tpsl_order_ids: bigint[];
400
400
  }>;
401
401
  readonly Orderbook: z.ZodObject<{
402
402
  asset_id: z.ZodNumber;
403
403
  bids: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
404
- order_ids: z.ZodArray<z.ZodNumber, "many">;
405
- total_size: z.ZodNumber;
404
+ order_ids: z.ZodArray<z.ZodBigInt, "many">;
405
+ total_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
406
406
  }, "strip", z.ZodTypeAny, {
407
- order_ids: number[];
408
- total_size: number;
407
+ order_ids: bigint[];
408
+ total_size: import("decimal.js").Decimal;
409
409
  }, {
410
- order_ids: number[];
411
- total_size: number;
412
- }>>, Map<any, {
413
- order_ids: number[];
414
- total_size: number;
410
+ order_ids: bigint[];
411
+ total_size: string | number;
412
+ }>>, Map<string, {
413
+ order_ids: bigint[];
414
+ total_size: import("decimal.js").Decimal;
415
415
  }>, Record<string, {
416
- order_ids: number[];
417
- total_size: number;
416
+ order_ids: bigint[];
417
+ total_size: string | number;
418
418
  }>>;
419
419
  asks: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
420
- order_ids: z.ZodArray<z.ZodNumber, "many">;
421
- total_size: z.ZodNumber;
420
+ order_ids: z.ZodArray<z.ZodBigInt, "many">;
421
+ total_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
422
422
  }, "strip", z.ZodTypeAny, {
423
- order_ids: number[];
424
- total_size: number;
423
+ order_ids: bigint[];
424
+ total_size: import("decimal.js").Decimal;
425
425
  }, {
426
- order_ids: number[];
427
- total_size: number;
428
- }>>, Map<any, {
429
- order_ids: number[];
430
- total_size: number;
426
+ order_ids: bigint[];
427
+ total_size: string | number;
428
+ }>>, Map<string, {
429
+ order_ids: bigint[];
430
+ total_size: import("decimal.js").Decimal;
431
431
  }>, Record<string, {
432
- order_ids: number[];
433
- total_size: number;
432
+ order_ids: bigint[];
433
+ total_size: string | number;
434
434
  }>>;
435
435
  }, "strip", z.ZodTypeAny, {
436
436
  asset_id: number;
437
- bids: Map<any, {
438
- order_ids: number[];
439
- total_size: number;
437
+ bids: Map<string, {
438
+ order_ids: bigint[];
439
+ total_size: import("decimal.js").Decimal;
440
440
  }>;
441
- asks: Map<any, {
442
- order_ids: number[];
443
- total_size: number;
441
+ asks: Map<string, {
442
+ order_ids: bigint[];
443
+ total_size: import("decimal.js").Decimal;
444
444
  }>;
445
445
  }, {
446
446
  asset_id: number;
447
447
  bids: Record<string, {
448
- order_ids: number[];
449
- total_size: number;
448
+ order_ids: bigint[];
449
+ total_size: string | number;
450
450
  }>;
451
451
  asks: Record<string, {
452
- order_ids: number[];
453
- total_size: number;
452
+ order_ids: bigint[];
453
+ total_size: string | number;
454
454
  }>;
455
455
  }>;
456
456
  readonly UsdcPnlPool: z.ZodObject<{
457
- usdc_token_amount: z.ZodNumber;
458
- external_deposits: z.ZodRecord<z.ZodString, z.ZodNumber>;
457
+ usdc_token_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
458
+ external_deposits: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>>, Map<string, import("decimal.js").Decimal>, Record<string, string | number>>;
459
459
  }, "strip", z.ZodTypeAny, {
460
- usdc_token_amount: number;
461
- external_deposits: Record<string, number>;
460
+ usdc_token_amount: import("decimal.js").Decimal;
461
+ external_deposits: Map<string, import("decimal.js").Decimal>;
462
462
  }, {
463
- usdc_token_amount: number;
464
- external_deposits: Record<string, number>;
463
+ usdc_token_amount: string | number;
464
+ external_deposits: Record<string, string | number>;
465
465
  }>;
466
466
  readonly UsdcInsuranceFund: z.ZodObject<{
467
- usdc_token_amount: z.ZodNumber;
468
- external_deposits: z.ZodRecord<z.ZodString, z.ZodNumber>;
469
- minimum_usdc_token_amount: z.ZodNumber;
467
+ usdc_token_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
468
+ external_deposits: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>>, Map<string, import("decimal.js").Decimal>, Record<string, string | number>>;
469
+ minimum_usdc_token_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
470
470
  }, "strip", z.ZodTypeAny, {
471
- usdc_token_amount: number;
472
- external_deposits: Record<string, number>;
473
- minimum_usdc_token_amount: number;
471
+ usdc_token_amount: import("decimal.js").Decimal;
472
+ external_deposits: Map<string, import("decimal.js").Decimal>;
473
+ minimum_usdc_token_amount: import("decimal.js").Decimal;
474
474
  }, {
475
- usdc_token_amount: number;
476
- external_deposits: Record<string, number>;
477
- minimum_usdc_token_amount: number;
475
+ usdc_token_amount: string | number;
476
+ external_deposits: Record<string, string | number>;
477
+ minimum_usdc_token_amount: string | number;
478
478
  }>;
479
479
  readonly UserAccount: z.ZodObject<{
480
480
  usdc_ledger: z.ZodObject<{
481
481
  ledger: z.ZodObject<{
482
482
  weights: z.ZodObject<{
483
- asset_weight: z.ZodNumber;
484
- initial_liability_weight: z.ZodNumber;
485
- maintenance_liability_weight: z.ZodNumber;
483
+ asset_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
484
+ initial_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
485
+ maintenance_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
486
486
  }, "strip", z.ZodTypeAny, {
487
- asset_weight: number;
488
- initial_liability_weight: number;
489
- maintenance_liability_weight: number;
487
+ asset_weight: import("decimal.js").Decimal;
488
+ initial_liability_weight: import("decimal.js").Decimal;
489
+ maintenance_liability_weight: import("decimal.js").Decimal;
490
490
  }, {
491
- asset_weight: number;
492
- initial_liability_weight: number;
493
- maintenance_liability_weight: number;
491
+ asset_weight: string | number;
492
+ initial_liability_weight: string | number;
493
+ maintenance_liability_weight: string | number;
494
494
  }>;
495
- asset: z.ZodNumber;
496
- liability: z.ZodNumber;
495
+ asset: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
496
+ liability: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
497
497
  }, "strip", z.ZodTypeAny, {
498
498
  weights: {
499
- asset_weight: number;
500
- initial_liability_weight: number;
501
- maintenance_liability_weight: number;
499
+ asset_weight: import("decimal.js").Decimal;
500
+ initial_liability_weight: import("decimal.js").Decimal;
501
+ maintenance_liability_weight: import("decimal.js").Decimal;
502
502
  };
503
- asset: number;
504
- liability: number;
503
+ asset: import("decimal.js").Decimal;
504
+ liability: import("decimal.js").Decimal;
505
505
  }, {
506
506
  weights: {
507
- asset_weight: number;
508
- initial_liability_weight: number;
509
- maintenance_liability_weight: number;
507
+ asset_weight: string | number;
508
+ initial_liability_weight: string | number;
509
+ maintenance_liability_weight: string | number;
510
510
  };
511
- asset: number;
512
- liability: number;
511
+ asset: string | number;
512
+ liability: string | number;
513
513
  }>;
514
- unrealized_loss_borrow: z.ZodNumber;
515
- unsettled_perp_profit: z.ZodNumber;
514
+ unrealized_loss_borrow: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
515
+ unsettled_perp_profit: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
516
516
  }, "strip", z.ZodTypeAny, {
517
517
  ledger: {
518
518
  weights: {
519
- asset_weight: number;
520
- initial_liability_weight: number;
521
- maintenance_liability_weight: number;
519
+ asset_weight: import("decimal.js").Decimal;
520
+ initial_liability_weight: import("decimal.js").Decimal;
521
+ maintenance_liability_weight: import("decimal.js").Decimal;
522
522
  };
523
- asset: number;
524
- liability: number;
523
+ asset: import("decimal.js").Decimal;
524
+ liability: import("decimal.js").Decimal;
525
525
  };
526
- unrealized_loss_borrow: number;
527
- unsettled_perp_profit: number;
526
+ unrealized_loss_borrow: import("decimal.js").Decimal;
527
+ unsettled_perp_profit: import("decimal.js").Decimal;
528
528
  }, {
529
529
  ledger: {
530
530
  weights: {
531
- asset_weight: number;
532
- initial_liability_weight: number;
533
- maintenance_liability_weight: number;
531
+ asset_weight: string | number;
532
+ initial_liability_weight: string | number;
533
+ maintenance_liability_weight: string | number;
534
534
  };
535
- asset: number;
536
- liability: number;
535
+ asset: string | number;
536
+ liability: string | number;
537
537
  };
538
- unrealized_loss_borrow: number;
539
- unsettled_perp_profit: number;
538
+ unrealized_loss_borrow: string | number;
539
+ unsettled_perp_profit: string | number;
540
540
  }>;
541
541
  spot_ledgers: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
542
542
  weights: z.ZodObject<{
543
- asset_weight: z.ZodNumber;
544
- initial_liability_weight: z.ZodNumber;
545
- maintenance_liability_weight: z.ZodNumber;
543
+ asset_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
544
+ initial_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
545
+ maintenance_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
546
546
  }, "strip", z.ZodTypeAny, {
547
- asset_weight: number;
548
- initial_liability_weight: number;
549
- maintenance_liability_weight: number;
547
+ asset_weight: import("decimal.js").Decimal;
548
+ initial_liability_weight: import("decimal.js").Decimal;
549
+ maintenance_liability_weight: import("decimal.js").Decimal;
550
550
  }, {
551
- asset_weight: number;
552
- initial_liability_weight: number;
553
- maintenance_liability_weight: number;
551
+ asset_weight: string | number;
552
+ initial_liability_weight: string | number;
553
+ maintenance_liability_weight: string | number;
554
554
  }>;
555
- asset: z.ZodNumber;
556
- liability: z.ZodNumber;
555
+ asset: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
556
+ liability: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
557
557
  }, "strip", z.ZodTypeAny, {
558
558
  weights: {
559
- asset_weight: number;
560
- initial_liability_weight: number;
561
- maintenance_liability_weight: number;
559
+ asset_weight: import("decimal.js").Decimal;
560
+ initial_liability_weight: import("decimal.js").Decimal;
561
+ maintenance_liability_weight: import("decimal.js").Decimal;
562
562
  };
563
- asset: number;
564
- liability: number;
563
+ asset: import("decimal.js").Decimal;
564
+ liability: import("decimal.js").Decimal;
565
565
  }, {
566
566
  weights: {
567
- asset_weight: number;
568
- initial_liability_weight: number;
569
- maintenance_liability_weight: number;
567
+ asset_weight: string | number;
568
+ initial_liability_weight: string | number;
569
+ maintenance_liability_weight: string | number;
570
570
  };
571
- asset: number;
572
- liability: number;
573
- }>>, Map<any, {
571
+ asset: string | number;
572
+ liability: string | number;
573
+ }>>, Map<number, {
574
574
  weights: {
575
- asset_weight: number;
576
- initial_liability_weight: number;
577
- maintenance_liability_weight: number;
575
+ asset_weight: import("decimal.js").Decimal;
576
+ initial_liability_weight: import("decimal.js").Decimal;
577
+ maintenance_liability_weight: import("decimal.js").Decimal;
578
578
  };
579
- asset: number;
580
- liability: number;
579
+ asset: import("decimal.js").Decimal;
580
+ liability: import("decimal.js").Decimal;
581
581
  }>, Record<string, {
582
582
  weights: {
583
- asset_weight: number;
584
- initial_liability_weight: number;
585
- maintenance_liability_weight: number;
583
+ asset_weight: string | number;
584
+ initial_liability_weight: string | number;
585
+ maintenance_liability_weight: string | number;
586
586
  };
587
- asset: number;
588
- liability: number;
587
+ asset: string | number;
588
+ liability: string | number;
589
589
  }>>;
590
590
  perp_ledgers: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
591
591
  orders: z.ZodArray<z.ZodObject<{
592
- size: z.ZodNumber;
593
- price: z.ZodNumber;
592
+ size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
593
+ price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
594
594
  side: z.ZodEnum<["Bid", "Ask"]>;
595
- order_id: z.ZodNumber;
595
+ order_id: z.ZodBigInt;
596
596
  reduce_only: z.ZodBoolean;
597
597
  }, "strip", z.ZodTypeAny, {
598
- size: number;
599
- price: number;
598
+ size: import("decimal.js").Decimal;
599
+ price: import("decimal.js").Decimal;
600
600
  side: "Bid" | "Ask";
601
- order_id: number;
601
+ order_id: bigint;
602
602
  reduce_only: boolean;
603
603
  }, {
604
- size: number;
605
- price: number;
604
+ size: string | number;
605
+ price: string | number;
606
606
  side: "Bid" | "Ask";
607
- order_id: number;
607
+ order_id: bigint;
608
608
  reduce_only: boolean;
609
609
  }>, "many">;
610
610
  position: z.ZodObject<{
611
- size: z.ZodNumber;
612
- cost_of_trades: z.ZodNumber;
613
- realized_pnl: z.ZodNumber;
614
- cached_mark_price: z.ZodNumber;
615
- last_accum_funding_applied_per_lot: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
616
- funding_payments_on_side: z.ZodNumber;
617
- funding_payments_on_position: z.ZodNumber;
611
+ size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
612
+ cost_of_trades: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
613
+ realized_pnl: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
614
+ cached_mark_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
615
+ last_accum_funding_applied_per_lot: z.ZodTuple<[z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>, z.ZodBigInt], null>;
616
+ funding_payments_on_side: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
617
+ funding_payments_on_position: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
618
618
  }, "strip", z.ZodTypeAny, {
619
- size: number;
620
- cost_of_trades: number;
621
- realized_pnl: number;
622
- cached_mark_price: number;
623
- last_accum_funding_applied_per_lot: [number, number];
624
- funding_payments_on_side: number;
625
- funding_payments_on_position: number;
619
+ size: import("decimal.js").Decimal;
620
+ cost_of_trades: import("decimal.js").Decimal;
621
+ realized_pnl: import("decimal.js").Decimal;
622
+ cached_mark_price: import("decimal.js").Decimal;
623
+ last_accum_funding_applied_per_lot: [import("decimal.js").Decimal, bigint];
624
+ funding_payments_on_side: import("decimal.js").Decimal;
625
+ funding_payments_on_position: import("decimal.js").Decimal;
626
626
  }, {
627
- size: number;
628
- cost_of_trades: number;
629
- realized_pnl: number;
630
- cached_mark_price: number;
631
- last_accum_funding_applied_per_lot: [number, number];
632
- funding_payments_on_side: number;
633
- funding_payments_on_position: number;
627
+ size: string | number;
628
+ cost_of_trades: string | number;
629
+ realized_pnl: string | number;
630
+ cached_mark_price: string | number;
631
+ last_accum_funding_applied_per_lot: [string | number, bigint];
632
+ funding_payments_on_side: string | number;
633
+ funding_payments_on_position: string | number;
634
634
  }>;
635
635
  user_selected_max_leverage: z.ZodNumber;
636
636
  tpsls: z.ZodArray<z.ZodObject<{
637
637
  side: z.ZodEnum<["Bid", "Ask"]>;
638
- tpsl_order_id: z.ZodNumber;
639
- order_price: z.ZodNumber;
640
- trigger_price: z.ZodNumber;
638
+ tpsl_order_id: z.ZodBigInt;
639
+ order_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
640
+ trigger_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
641
641
  trigger_direction: z.ZodEnum<["GreaterThanOrEqual", "LessThanOrEqual"]>;
642
642
  tpsl_price_condition: z.ZodEnum<["Mark", "Oracle", "LastTrade"]>;
643
- active_size: z.ZodNumber;
644
- full_size: z.ZodNumber;
643
+ active_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
644
+ full_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
645
645
  order_type: z.ZodEnum<["Limit", "PostOnly", "FillOrKill", "ImmediateOrCancel", "PostOnlySlide", "PostOnlyFront"]>;
646
- parent_order_id: z.ZodOptional<z.ZodNumber>;
647
- linked_tpsl_order_ids: z.ZodArray<z.ZodNumber, "many">;
646
+ parent_order_id: z.ZodOptional<z.ZodBigInt>;
647
+ linked_tpsl_order_ids: z.ZodArray<z.ZodBigInt, "many">;
648
648
  }, "strip", z.ZodTypeAny, {
649
649
  side: "Bid" | "Ask";
650
- tpsl_order_id: number;
651
- order_price: number;
652
- trigger_price: number;
650
+ tpsl_order_id: bigint;
651
+ order_price: import("decimal.js").Decimal;
652
+ trigger_price: import("decimal.js").Decimal;
653
653
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
654
654
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
655
- active_size: number;
656
- full_size: number;
655
+ active_size: import("decimal.js").Decimal;
656
+ full_size: import("decimal.js").Decimal;
657
657
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
658
- linked_tpsl_order_ids: number[];
659
- parent_order_id?: number | undefined;
658
+ linked_tpsl_order_ids: bigint[];
659
+ parent_order_id?: bigint | undefined;
660
660
  }, {
661
661
  side: "Bid" | "Ask";
662
- tpsl_order_id: number;
663
- order_price: number;
664
- trigger_price: number;
662
+ tpsl_order_id: bigint;
663
+ order_price: string | number;
664
+ trigger_price: string | number;
665
665
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
666
666
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
667
- active_size: number;
668
- full_size: number;
667
+ active_size: string | number;
668
+ full_size: string | number;
669
669
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
670
- linked_tpsl_order_ids: number[];
671
- parent_order_id?: number | undefined;
670
+ linked_tpsl_order_ids: bigint[];
671
+ parent_order_id?: bigint | undefined;
672
672
  }>, "many">;
673
673
  }, "strip", z.ZodTypeAny, {
674
674
  orders: {
675
- size: number;
676
- price: number;
675
+ size: import("decimal.js").Decimal;
676
+ price: import("decimal.js").Decimal;
677
677
  side: "Bid" | "Ask";
678
- order_id: number;
678
+ order_id: bigint;
679
679
  reduce_only: boolean;
680
680
  }[];
681
681
  position: {
682
- size: number;
683
- cost_of_trades: number;
684
- realized_pnl: number;
685
- cached_mark_price: number;
686
- last_accum_funding_applied_per_lot: [number, number];
687
- funding_payments_on_side: number;
688
- funding_payments_on_position: number;
682
+ size: import("decimal.js").Decimal;
683
+ cost_of_trades: import("decimal.js").Decimal;
684
+ realized_pnl: import("decimal.js").Decimal;
685
+ cached_mark_price: import("decimal.js").Decimal;
686
+ last_accum_funding_applied_per_lot: [import("decimal.js").Decimal, bigint];
687
+ funding_payments_on_side: import("decimal.js").Decimal;
688
+ funding_payments_on_position: import("decimal.js").Decimal;
689
689
  };
690
690
  user_selected_max_leverage: number;
691
691
  tpsls: {
692
692
  side: "Bid" | "Ask";
693
- tpsl_order_id: number;
694
- order_price: number;
695
- trigger_price: number;
693
+ tpsl_order_id: bigint;
694
+ order_price: import("decimal.js").Decimal;
695
+ trigger_price: import("decimal.js").Decimal;
696
696
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
697
697
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
698
- active_size: number;
699
- full_size: number;
698
+ active_size: import("decimal.js").Decimal;
699
+ full_size: import("decimal.js").Decimal;
700
700
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
701
- linked_tpsl_order_ids: number[];
702
- parent_order_id?: number | undefined;
701
+ linked_tpsl_order_ids: bigint[];
702
+ parent_order_id?: bigint | undefined;
703
703
  }[];
704
704
  }, {
705
705
  orders: {
706
- size: number;
707
- price: number;
706
+ size: string | number;
707
+ price: string | number;
708
708
  side: "Bid" | "Ask";
709
- order_id: number;
709
+ order_id: bigint;
710
710
  reduce_only: boolean;
711
711
  }[];
712
712
  position: {
713
- size: number;
714
- cost_of_trades: number;
715
- realized_pnl: number;
716
- cached_mark_price: number;
717
- last_accum_funding_applied_per_lot: [number, number];
718
- funding_payments_on_side: number;
719
- funding_payments_on_position: number;
713
+ size: string | number;
714
+ cost_of_trades: string | number;
715
+ realized_pnl: string | number;
716
+ cached_mark_price: string | number;
717
+ last_accum_funding_applied_per_lot: [string | number, bigint];
718
+ funding_payments_on_side: string | number;
719
+ funding_payments_on_position: string | number;
720
720
  };
721
721
  user_selected_max_leverage: number;
722
722
  tpsls: {
723
723
  side: "Bid" | "Ask";
724
- tpsl_order_id: number;
725
- order_price: number;
726
- trigger_price: number;
724
+ tpsl_order_id: bigint;
725
+ order_price: string | number;
726
+ trigger_price: string | number;
727
727
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
728
728
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
729
- active_size: number;
730
- full_size: number;
729
+ active_size: string | number;
730
+ full_size: string | number;
731
731
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
732
- linked_tpsl_order_ids: number[];
733
- parent_order_id?: number | undefined;
732
+ linked_tpsl_order_ids: bigint[];
733
+ parent_order_id?: bigint | undefined;
734
734
  }[];
735
- }>>, Map<any, {
735
+ }>>, Map<number, {
736
736
  orders: {
737
- size: number;
738
- price: number;
737
+ size: import("decimal.js").Decimal;
738
+ price: import("decimal.js").Decimal;
739
739
  side: "Bid" | "Ask";
740
- order_id: number;
740
+ order_id: bigint;
741
741
  reduce_only: boolean;
742
742
  }[];
743
743
  position: {
744
- size: number;
745
- cost_of_trades: number;
746
- realized_pnl: number;
747
- cached_mark_price: number;
748
- last_accum_funding_applied_per_lot: [number, number];
749
- funding_payments_on_side: number;
750
- funding_payments_on_position: number;
744
+ size: import("decimal.js").Decimal;
745
+ cost_of_trades: import("decimal.js").Decimal;
746
+ realized_pnl: import("decimal.js").Decimal;
747
+ cached_mark_price: import("decimal.js").Decimal;
748
+ last_accum_funding_applied_per_lot: [import("decimal.js").Decimal, bigint];
749
+ funding_payments_on_side: import("decimal.js").Decimal;
750
+ funding_payments_on_position: import("decimal.js").Decimal;
751
751
  };
752
752
  user_selected_max_leverage: number;
753
753
  tpsls: {
754
754
  side: "Bid" | "Ask";
755
- tpsl_order_id: number;
756
- order_price: number;
757
- trigger_price: number;
755
+ tpsl_order_id: bigint;
756
+ order_price: import("decimal.js").Decimal;
757
+ trigger_price: import("decimal.js").Decimal;
758
758
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
759
759
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
760
- active_size: number;
761
- full_size: number;
760
+ active_size: import("decimal.js").Decimal;
761
+ full_size: import("decimal.js").Decimal;
762
762
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
763
- linked_tpsl_order_ids: number[];
764
- parent_order_id?: number | undefined;
763
+ linked_tpsl_order_ids: bigint[];
764
+ parent_order_id?: bigint | undefined;
765
765
  }[];
766
766
  }>, Record<string, {
767
767
  orders: {
768
- size: number;
769
- price: number;
768
+ size: string | number;
769
+ price: string | number;
770
770
  side: "Bid" | "Ask";
771
- order_id: number;
771
+ order_id: bigint;
772
772
  reduce_only: boolean;
773
773
  }[];
774
774
  position: {
775
- size: number;
776
- cost_of_trades: number;
777
- realized_pnl: number;
778
- cached_mark_price: number;
779
- last_accum_funding_applied_per_lot: [number, number];
780
- funding_payments_on_side: number;
781
- funding_payments_on_position: number;
775
+ size: string | number;
776
+ cost_of_trades: string | number;
777
+ realized_pnl: string | number;
778
+ cached_mark_price: string | number;
779
+ last_accum_funding_applied_per_lot: [string | number, bigint];
780
+ funding_payments_on_side: string | number;
781
+ funding_payments_on_position: string | number;
782
782
  };
783
783
  user_selected_max_leverage: number;
784
784
  tpsls: {
785
785
  side: "Bid" | "Ask";
786
- tpsl_order_id: number;
787
- order_price: number;
788
- trigger_price: number;
786
+ tpsl_order_id: bigint;
787
+ order_price: string | number;
788
+ trigger_price: string | number;
789
789
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
790
790
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
791
- active_size: number;
792
- full_size: number;
791
+ active_size: string | number;
792
+ full_size: string | number;
793
793
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
794
- linked_tpsl_order_ids: number[];
795
- parent_order_id?: number | undefined;
794
+ linked_tpsl_order_ids: bigint[];
795
+ parent_order_id?: bigint | undefined;
796
796
  }[];
797
797
  }>>;
798
798
  }, "strip", z.ZodTypeAny, {
799
799
  usdc_ledger: {
800
800
  ledger: {
801
801
  weights: {
802
- asset_weight: number;
803
- initial_liability_weight: number;
804
- maintenance_liability_weight: number;
802
+ asset_weight: import("decimal.js").Decimal;
803
+ initial_liability_weight: import("decimal.js").Decimal;
804
+ maintenance_liability_weight: import("decimal.js").Decimal;
805
805
  };
806
- asset: number;
807
- liability: number;
806
+ asset: import("decimal.js").Decimal;
807
+ liability: import("decimal.js").Decimal;
808
808
  };
809
- unrealized_loss_borrow: number;
810
- unsettled_perp_profit: number;
809
+ unrealized_loss_borrow: import("decimal.js").Decimal;
810
+ unsettled_perp_profit: import("decimal.js").Decimal;
811
811
  };
812
- spot_ledgers: Map<any, {
812
+ spot_ledgers: Map<number, {
813
813
  weights: {
814
- asset_weight: number;
815
- initial_liability_weight: number;
816
- maintenance_liability_weight: number;
814
+ asset_weight: import("decimal.js").Decimal;
815
+ initial_liability_weight: import("decimal.js").Decimal;
816
+ maintenance_liability_weight: import("decimal.js").Decimal;
817
817
  };
818
- asset: number;
819
- liability: number;
818
+ asset: import("decimal.js").Decimal;
819
+ liability: import("decimal.js").Decimal;
820
820
  }>;
821
- perp_ledgers: Map<any, {
821
+ perp_ledgers: Map<number, {
822
822
  orders: {
823
- size: number;
824
- price: number;
823
+ size: import("decimal.js").Decimal;
824
+ price: import("decimal.js").Decimal;
825
825
  side: "Bid" | "Ask";
826
- order_id: number;
826
+ order_id: bigint;
827
827
  reduce_only: boolean;
828
828
  }[];
829
829
  position: {
830
- size: number;
831
- cost_of_trades: number;
832
- realized_pnl: number;
833
- cached_mark_price: number;
834
- last_accum_funding_applied_per_lot: [number, number];
835
- funding_payments_on_side: number;
836
- funding_payments_on_position: number;
830
+ size: import("decimal.js").Decimal;
831
+ cost_of_trades: import("decimal.js").Decimal;
832
+ realized_pnl: import("decimal.js").Decimal;
833
+ cached_mark_price: import("decimal.js").Decimal;
834
+ last_accum_funding_applied_per_lot: [import("decimal.js").Decimal, bigint];
835
+ funding_payments_on_side: import("decimal.js").Decimal;
836
+ funding_payments_on_position: import("decimal.js").Decimal;
837
837
  };
838
838
  user_selected_max_leverage: number;
839
839
  tpsls: {
840
840
  side: "Bid" | "Ask";
841
- tpsl_order_id: number;
842
- order_price: number;
843
- trigger_price: number;
841
+ tpsl_order_id: bigint;
842
+ order_price: import("decimal.js").Decimal;
843
+ trigger_price: import("decimal.js").Decimal;
844
844
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
845
845
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
846
- active_size: number;
847
- full_size: number;
846
+ active_size: import("decimal.js").Decimal;
847
+ full_size: import("decimal.js").Decimal;
848
848
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
849
- linked_tpsl_order_ids: number[];
850
- parent_order_id?: number | undefined;
849
+ linked_tpsl_order_ids: bigint[];
850
+ parent_order_id?: bigint | undefined;
851
851
  }[];
852
852
  }>;
853
853
  }, {
854
854
  usdc_ledger: {
855
855
  ledger: {
856
856
  weights: {
857
- asset_weight: number;
858
- initial_liability_weight: number;
859
- maintenance_liability_weight: number;
857
+ asset_weight: string | number;
858
+ initial_liability_weight: string | number;
859
+ maintenance_liability_weight: string | number;
860
860
  };
861
- asset: number;
862
- liability: number;
861
+ asset: string | number;
862
+ liability: string | number;
863
863
  };
864
- unrealized_loss_borrow: number;
865
- unsettled_perp_profit: number;
864
+ unrealized_loss_borrow: string | number;
865
+ unsettled_perp_profit: string | number;
866
866
  };
867
867
  spot_ledgers: Record<string, {
868
868
  weights: {
869
- asset_weight: number;
870
- initial_liability_weight: number;
871
- maintenance_liability_weight: number;
869
+ asset_weight: string | number;
870
+ initial_liability_weight: string | number;
871
+ maintenance_liability_weight: string | number;
872
872
  };
873
- asset: number;
874
- liability: number;
873
+ asset: string | number;
874
+ liability: string | number;
875
875
  }>;
876
876
  perp_ledgers: Record<string, {
877
877
  orders: {
878
- size: number;
879
- price: number;
878
+ size: string | number;
879
+ price: string | number;
880
880
  side: "Bid" | "Ask";
881
- order_id: number;
881
+ order_id: bigint;
882
882
  reduce_only: boolean;
883
883
  }[];
884
884
  position: {
885
- size: number;
886
- cost_of_trades: number;
887
- realized_pnl: number;
888
- cached_mark_price: number;
889
- last_accum_funding_applied_per_lot: [number, number];
890
- funding_payments_on_side: number;
891
- funding_payments_on_position: number;
885
+ size: string | number;
886
+ cost_of_trades: string | number;
887
+ realized_pnl: string | number;
888
+ cached_mark_price: string | number;
889
+ last_accum_funding_applied_per_lot: [string | number, bigint];
890
+ funding_payments_on_side: string | number;
891
+ funding_payments_on_position: string | number;
892
892
  };
893
893
  user_selected_max_leverage: number;
894
894
  tpsls: {
895
895
  side: "Bid" | "Ask";
896
- tpsl_order_id: number;
897
- order_price: number;
898
- trigger_price: number;
896
+ tpsl_order_id: bigint;
897
+ order_price: string | number;
898
+ trigger_price: string | number;
899
899
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
900
900
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
901
- active_size: number;
902
- full_size: number;
901
+ active_size: string | number;
902
+ full_size: string | number;
903
903
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
904
- linked_tpsl_order_ids: number[];
905
- parent_order_id?: number | undefined;
904
+ linked_tpsl_order_ids: bigint[];
905
+ parent_order_id?: bigint | undefined;
906
906
  }[];
907
907
  }>;
908
908
  }>;
909
909
  readonly Pricing: z.ZodObject<{
910
910
  pricing_frequency_seconds: z.ZodNumber;
911
911
  prices_info: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
912
- mark_price: z.ZodNumber;
913
- oracle_price: z.ZodNumber;
914
- publish_timestamp: z.ZodNumber;
912
+ mark_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
913
+ oracle_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
914
+ publish_timestamp: z.ZodBigInt;
915
915
  }, "strip", z.ZodTypeAny, {
916
- mark_price: number;
917
- oracle_price: number;
918
- publish_timestamp: number;
916
+ mark_price: import("decimal.js").Decimal;
917
+ oracle_price: import("decimal.js").Decimal;
918
+ publish_timestamp: bigint;
919
919
  }, {
920
- mark_price: number;
921
- oracle_price: number;
922
- publish_timestamp: number;
923
- }>>, Map<any, {
924
- mark_price: number;
925
- oracle_price: number;
926
- publish_timestamp: number;
920
+ mark_price: string | number;
921
+ oracle_price: string | number;
922
+ publish_timestamp: bigint;
923
+ }>>, Map<number, {
924
+ mark_price: import("decimal.js").Decimal;
925
+ oracle_price: import("decimal.js").Decimal;
926
+ publish_timestamp: bigint;
927
927
  }>, Record<string, {
928
- mark_price: number;
929
- oracle_price: number;
930
- publish_timestamp: number;
928
+ mark_price: string | number;
929
+ oracle_price: string | number;
930
+ publish_timestamp: bigint;
931
931
  }>>;
932
932
  premium_index: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
933
- weighted_premium_sum: z.ZodNumber;
934
- duration_sum: z.ZodNumber;
935
- last_update_timestamp: z.ZodNullable<z.ZodNumber>;
933
+ weighted_premium_sum: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
934
+ duration_sum: z.ZodBigInt;
935
+ last_update_timestamp: z.ZodNullable<z.ZodBigInt>;
936
936
  }, "strip", z.ZodTypeAny, {
937
- last_update_timestamp: number | null;
938
- weighted_premium_sum: number;
939
- duration_sum: number;
937
+ last_update_timestamp: bigint | null;
938
+ weighted_premium_sum: import("decimal.js").Decimal;
939
+ duration_sum: bigint;
940
940
  }, {
941
- last_update_timestamp: number | null;
942
- weighted_premium_sum: number;
943
- duration_sum: number;
944
- }>>, Map<any, {
945
- last_update_timestamp: number | null;
946
- weighted_premium_sum: number;
947
- duration_sum: number;
941
+ last_update_timestamp: bigint | null;
942
+ weighted_premium_sum: string | number;
943
+ duration_sum: bigint;
944
+ }>>, Map<number, {
945
+ last_update_timestamp: bigint | null;
946
+ weighted_premium_sum: import("decimal.js").Decimal;
947
+ duration_sum: bigint;
948
948
  }>, Record<string, {
949
- last_update_timestamp: number | null;
950
- weighted_premium_sum: number;
951
- duration_sum: number;
949
+ last_update_timestamp: bigint | null;
950
+ weighted_premium_sum: string | number;
951
+ duration_sum: bigint;
952
952
  }>>;
953
- funding_rates: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, Map<any, [number, number]>, Record<string, [number, number]>>;
954
- accum_funding_per_lot: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, Map<any, [number, number]>, Record<string, [number, number]>>;
953
+ funding_rates: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>, z.ZodBigInt], null>>, Map<number, [import("decimal.js").Decimal, bigint]>, Record<string, [string | number, bigint]>>;
954
+ accum_funding_per_lot: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>, z.ZodBigInt], null>>, Map<number, [import("decimal.js").Decimal, bigint]>, Record<string, [string | number, bigint]>>;
955
955
  }, "strip", z.ZodTypeAny, {
956
956
  pricing_frequency_seconds: number;
957
- prices_info: Map<any, {
958
- mark_price: number;
959
- oracle_price: number;
960
- publish_timestamp: number;
957
+ prices_info: Map<number, {
958
+ mark_price: import("decimal.js").Decimal;
959
+ oracle_price: import("decimal.js").Decimal;
960
+ publish_timestamp: bigint;
961
961
  }>;
962
- premium_index: Map<any, {
963
- last_update_timestamp: number | null;
964
- weighted_premium_sum: number;
965
- duration_sum: number;
962
+ premium_index: Map<number, {
963
+ last_update_timestamp: bigint | null;
964
+ weighted_premium_sum: import("decimal.js").Decimal;
965
+ duration_sum: bigint;
966
966
  }>;
967
- funding_rates: Map<any, [number, number]>;
968
- accum_funding_per_lot: Map<any, [number, number]>;
967
+ funding_rates: Map<number, [import("decimal.js").Decimal, bigint]>;
968
+ accum_funding_per_lot: Map<number, [import("decimal.js").Decimal, bigint]>;
969
969
  }, {
970
970
  pricing_frequency_seconds: number;
971
971
  prices_info: Record<string, {
972
- mark_price: number;
973
- oracle_price: number;
974
- publish_timestamp: number;
972
+ mark_price: string | number;
973
+ oracle_price: string | number;
974
+ publish_timestamp: bigint;
975
975
  }>;
976
976
  premium_index: Record<string, {
977
- last_update_timestamp: number | null;
978
- weighted_premium_sum: number;
979
- duration_sum: number;
977
+ last_update_timestamp: bigint | null;
978
+ weighted_premium_sum: string | number;
979
+ duration_sum: bigint;
980
980
  }>;
981
- funding_rates: Record<string, [number, number]>;
982
- accum_funding_per_lot: Record<string, [number, number]>;
981
+ funding_rates: Record<string, [string | number, bigint]>;
982
+ accum_funding_per_lot: Record<string, [string | number, bigint]>;
983
983
  }>;
984
984
  readonly EnrichedBorrowLendMarket: z.ZodObject<{
985
985
  market: z.ZodObject<{
986
986
  is_active: z.ZodBoolean;
987
- last_update_timestamp: z.ZodNumber;
987
+ last_update_timestamp: z.ZodBigInt;
988
988
  decimals: z.ZodNumber;
989
989
  risk_params: z.ZodObject<{
990
990
  weights: z.ZodObject<{
991
- asset_weight: z.ZodNumber;
992
- initial_liability_weight: z.ZodNumber;
993
- maintenance_liability_weight: z.ZodNumber;
991
+ asset_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
992
+ initial_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
993
+ maintenance_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
994
994
  }, "strip", z.ZodTypeAny, {
995
- asset_weight: number;
996
- initial_liability_weight: number;
997
- maintenance_liability_weight: number;
995
+ asset_weight: import("decimal.js").Decimal;
996
+ initial_liability_weight: import("decimal.js").Decimal;
997
+ maintenance_liability_weight: import("decimal.js").Decimal;
998
998
  }, {
999
- asset_weight: number;
1000
- initial_liability_weight: number;
1001
- maintenance_liability_weight: number;
999
+ asset_weight: string | number;
1000
+ initial_liability_weight: string | number;
1001
+ maintenance_liability_weight: string | number;
1002
1002
  }>;
1003
- deposit_limit: z.ZodNumber;
1004
- borrow_limit: z.ZodNumber;
1005
- liquidation_reward_ratio: z.ZodNumber;
1006
- liability_liquidation_limit_ratio: z.ZodNumber;
1003
+ deposit_limit: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1004
+ borrow_limit: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1005
+ liquidation_reward_ratio: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1006
+ liability_liquidation_limit_ratio: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1007
1007
  }, "strip", z.ZodTypeAny, {
1008
1008
  weights: {
1009
- asset_weight: number;
1010
- initial_liability_weight: number;
1011
- maintenance_liability_weight: number;
1009
+ asset_weight: import("decimal.js").Decimal;
1010
+ initial_liability_weight: import("decimal.js").Decimal;
1011
+ maintenance_liability_weight: import("decimal.js").Decimal;
1012
1012
  };
1013
- deposit_limit: number;
1014
- borrow_limit: number;
1015
- liquidation_reward_ratio: number;
1016
- liability_liquidation_limit_ratio: number;
1013
+ deposit_limit: import("decimal.js").Decimal;
1014
+ borrow_limit: import("decimal.js").Decimal;
1015
+ liquidation_reward_ratio: import("decimal.js").Decimal;
1016
+ liability_liquidation_limit_ratio: import("decimal.js").Decimal;
1017
1017
  }, {
1018
1018
  weights: {
1019
- asset_weight: number;
1020
- initial_liability_weight: number;
1021
- maintenance_liability_weight: number;
1019
+ asset_weight: string | number;
1020
+ initial_liability_weight: string | number;
1021
+ maintenance_liability_weight: string | number;
1022
1022
  };
1023
- deposit_limit: number;
1024
- borrow_limit: number;
1025
- liquidation_reward_ratio: number;
1026
- liability_liquidation_limit_ratio: number;
1023
+ deposit_limit: string | number;
1024
+ borrow_limit: string | number;
1025
+ liquidation_reward_ratio: string | number;
1026
+ liability_liquidation_limit_ratio: string | number;
1027
1027
  }>;
1028
1028
  rate_params: z.ZodObject<{
1029
- optimal_utilisation_rate: z.ZodNumber;
1030
- min_borrow_rate: z.ZodNumber;
1031
- optimal_borrow_rate: z.ZodNumber;
1032
- max_borrow_rate: z.ZodNumber;
1029
+ optimal_utilisation_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1030
+ min_borrow_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1031
+ optimal_borrow_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1032
+ max_borrow_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1033
1033
  }, "strip", z.ZodTypeAny, {
1034
- optimal_utilisation_rate: number;
1035
- min_borrow_rate: number;
1036
- optimal_borrow_rate: number;
1037
- max_borrow_rate: number;
1034
+ optimal_utilisation_rate: import("decimal.js").Decimal;
1035
+ min_borrow_rate: import("decimal.js").Decimal;
1036
+ optimal_borrow_rate: import("decimal.js").Decimal;
1037
+ max_borrow_rate: import("decimal.js").Decimal;
1038
1038
  }, {
1039
- optimal_utilisation_rate: number;
1040
- min_borrow_rate: number;
1041
- optimal_borrow_rate: number;
1042
- max_borrow_rate: number;
1039
+ optimal_utilisation_rate: string | number;
1040
+ min_borrow_rate: string | number;
1041
+ optimal_borrow_rate: string | number;
1042
+ max_borrow_rate: string | number;
1043
1043
  }>;
1044
- available_amount: z.ZodNumber;
1045
- borrowed_amount: z.ZodNumber;
1046
- cumulative_deposit_rate: z.ZodNumber;
1047
- cumulative_borrow_rate: z.ZodNumber;
1048
- accumulated_protocol_fees: z.ZodNumber;
1044
+ available_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1045
+ borrowed_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1046
+ cumulative_deposit_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1047
+ cumulative_borrow_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1048
+ accumulated_protocol_fees: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1049
1049
  }, "strip", z.ZodTypeAny, {
1050
1050
  is_active: boolean;
1051
- last_update_timestamp: number;
1051
+ last_update_timestamp: bigint;
1052
1052
  decimals: number;
1053
1053
  risk_params: {
1054
1054
  weights: {
1055
- asset_weight: number;
1056
- initial_liability_weight: number;
1057
- maintenance_liability_weight: number;
1055
+ asset_weight: import("decimal.js").Decimal;
1056
+ initial_liability_weight: import("decimal.js").Decimal;
1057
+ maintenance_liability_weight: import("decimal.js").Decimal;
1058
1058
  };
1059
- deposit_limit: number;
1060
- borrow_limit: number;
1061
- liquidation_reward_ratio: number;
1062
- liability_liquidation_limit_ratio: number;
1059
+ deposit_limit: import("decimal.js").Decimal;
1060
+ borrow_limit: import("decimal.js").Decimal;
1061
+ liquidation_reward_ratio: import("decimal.js").Decimal;
1062
+ liability_liquidation_limit_ratio: import("decimal.js").Decimal;
1063
1063
  };
1064
1064
  rate_params: {
1065
- optimal_utilisation_rate: number;
1066
- min_borrow_rate: number;
1067
- optimal_borrow_rate: number;
1068
- max_borrow_rate: number;
1065
+ optimal_utilisation_rate: import("decimal.js").Decimal;
1066
+ min_borrow_rate: import("decimal.js").Decimal;
1067
+ optimal_borrow_rate: import("decimal.js").Decimal;
1068
+ max_borrow_rate: import("decimal.js").Decimal;
1069
1069
  };
1070
- available_amount: number;
1071
- borrowed_amount: number;
1072
- cumulative_deposit_rate: number;
1073
- cumulative_borrow_rate: number;
1074
- accumulated_protocol_fees: number;
1070
+ available_amount: import("decimal.js").Decimal;
1071
+ borrowed_amount: import("decimal.js").Decimal;
1072
+ cumulative_deposit_rate: import("decimal.js").Decimal;
1073
+ cumulative_borrow_rate: import("decimal.js").Decimal;
1074
+ accumulated_protocol_fees: import("decimal.js").Decimal;
1075
1075
  }, {
1076
1076
  is_active: boolean;
1077
- last_update_timestamp: number;
1077
+ last_update_timestamp: bigint;
1078
1078
  decimals: number;
1079
1079
  risk_params: {
1080
1080
  weights: {
1081
- asset_weight: number;
1082
- initial_liability_weight: number;
1083
- maintenance_liability_weight: number;
1081
+ asset_weight: string | number;
1082
+ initial_liability_weight: string | number;
1083
+ maintenance_liability_weight: string | number;
1084
1084
  };
1085
- deposit_limit: number;
1086
- borrow_limit: number;
1087
- liquidation_reward_ratio: number;
1088
- liability_liquidation_limit_ratio: number;
1085
+ deposit_limit: string | number;
1086
+ borrow_limit: string | number;
1087
+ liquidation_reward_ratio: string | number;
1088
+ liability_liquidation_limit_ratio: string | number;
1089
1089
  };
1090
1090
  rate_params: {
1091
- optimal_utilisation_rate: number;
1092
- min_borrow_rate: number;
1093
- optimal_borrow_rate: number;
1094
- max_borrow_rate: number;
1091
+ optimal_utilisation_rate: string | number;
1092
+ min_borrow_rate: string | number;
1093
+ optimal_borrow_rate: string | number;
1094
+ max_borrow_rate: string | number;
1095
1095
  };
1096
- available_amount: number;
1097
- borrowed_amount: number;
1098
- cumulative_deposit_rate: number;
1099
- cumulative_borrow_rate: number;
1100
- accumulated_protocol_fees: number;
1096
+ available_amount: string | number;
1097
+ borrowed_amount: string | number;
1098
+ cumulative_deposit_rate: string | number;
1099
+ cumulative_borrow_rate: string | number;
1100
+ accumulated_protocol_fees: string | number;
1101
1101
  }>;
1102
- utilisation_rate: z.ZodNumber;
1103
- current_deposit_rate: z.ZodNumber;
1104
- current_borrow_rate: z.ZodNumber;
1102
+ utilisation_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1103
+ current_deposit_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1104
+ current_borrow_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1105
1105
  }, "strip", z.ZodTypeAny, {
1106
1106
  market: {
1107
1107
  is_active: boolean;
1108
- last_update_timestamp: number;
1108
+ last_update_timestamp: bigint;
1109
1109
  decimals: number;
1110
1110
  risk_params: {
1111
1111
  weights: {
1112
- asset_weight: number;
1113
- initial_liability_weight: number;
1114
- maintenance_liability_weight: number;
1112
+ asset_weight: import("decimal.js").Decimal;
1113
+ initial_liability_weight: import("decimal.js").Decimal;
1114
+ maintenance_liability_weight: import("decimal.js").Decimal;
1115
1115
  };
1116
- deposit_limit: number;
1117
- borrow_limit: number;
1118
- liquidation_reward_ratio: number;
1119
- liability_liquidation_limit_ratio: number;
1116
+ deposit_limit: import("decimal.js").Decimal;
1117
+ borrow_limit: import("decimal.js").Decimal;
1118
+ liquidation_reward_ratio: import("decimal.js").Decimal;
1119
+ liability_liquidation_limit_ratio: import("decimal.js").Decimal;
1120
1120
  };
1121
1121
  rate_params: {
1122
- optimal_utilisation_rate: number;
1123
- min_borrow_rate: number;
1124
- optimal_borrow_rate: number;
1125
- max_borrow_rate: number;
1122
+ optimal_utilisation_rate: import("decimal.js").Decimal;
1123
+ min_borrow_rate: import("decimal.js").Decimal;
1124
+ optimal_borrow_rate: import("decimal.js").Decimal;
1125
+ max_borrow_rate: import("decimal.js").Decimal;
1126
1126
  };
1127
- available_amount: number;
1128
- borrowed_amount: number;
1129
- cumulative_deposit_rate: number;
1130
- cumulative_borrow_rate: number;
1131
- accumulated_protocol_fees: number;
1127
+ available_amount: import("decimal.js").Decimal;
1128
+ borrowed_amount: import("decimal.js").Decimal;
1129
+ cumulative_deposit_rate: import("decimal.js").Decimal;
1130
+ cumulative_borrow_rate: import("decimal.js").Decimal;
1131
+ accumulated_protocol_fees: import("decimal.js").Decimal;
1132
1132
  };
1133
- utilisation_rate: number;
1134
- current_deposit_rate: number;
1135
- current_borrow_rate: number;
1133
+ utilisation_rate: import("decimal.js").Decimal;
1134
+ current_deposit_rate: import("decimal.js").Decimal;
1135
+ current_borrow_rate: import("decimal.js").Decimal;
1136
1136
  }, {
1137
1137
  market: {
1138
1138
  is_active: boolean;
1139
- last_update_timestamp: number;
1139
+ last_update_timestamp: bigint;
1140
1140
  decimals: number;
1141
1141
  risk_params: {
1142
1142
  weights: {
1143
- asset_weight: number;
1144
- initial_liability_weight: number;
1145
- maintenance_liability_weight: number;
1143
+ asset_weight: string | number;
1144
+ initial_liability_weight: string | number;
1145
+ maintenance_liability_weight: string | number;
1146
1146
  };
1147
- deposit_limit: number;
1148
- borrow_limit: number;
1149
- liquidation_reward_ratio: number;
1150
- liability_liquidation_limit_ratio: number;
1147
+ deposit_limit: string | number;
1148
+ borrow_limit: string | number;
1149
+ liquidation_reward_ratio: string | number;
1150
+ liability_liquidation_limit_ratio: string | number;
1151
1151
  };
1152
1152
  rate_params: {
1153
- optimal_utilisation_rate: number;
1154
- min_borrow_rate: number;
1155
- optimal_borrow_rate: number;
1156
- max_borrow_rate: number;
1153
+ optimal_utilisation_rate: string | number;
1154
+ min_borrow_rate: string | number;
1155
+ optimal_borrow_rate: string | number;
1156
+ max_borrow_rate: string | number;
1157
1157
  };
1158
- available_amount: number;
1159
- borrowed_amount: number;
1160
- cumulative_deposit_rate: number;
1161
- cumulative_borrow_rate: number;
1162
- accumulated_protocol_fees: number;
1158
+ available_amount: string | number;
1159
+ borrowed_amount: string | number;
1160
+ cumulative_deposit_rate: string | number;
1161
+ cumulative_borrow_rate: string | number;
1162
+ accumulated_protocol_fees: string | number;
1163
1163
  };
1164
- utilisation_rate: number;
1165
- current_deposit_rate: number;
1166
- current_borrow_rate: number;
1164
+ utilisation_rate: string | number;
1165
+ current_deposit_rate: string | number;
1166
+ current_borrow_rate: string | number;
1167
1167
  }>;
1168
1168
  readonly PerpMarket: z.ZodObject<{
1169
1169
  is_active: z.ZodBoolean;
1170
- min_tick_size: z.ZodNumber;
1171
- min_lot_size: z.ZodNumber;
1172
- min_interest_rate_clamp: z.ZodNumber;
1173
- max_interest_rate_clamp: z.ZodNumber;
1174
- min_funding_rate_clamp: z.ZodNumber;
1175
- max_funding_rate_clamp: z.ZodNumber;
1176
- impact_margin: z.ZodNumber;
1177
- interest_rate: z.ZodNumber;
1170
+ min_tick_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1171
+ min_lot_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1172
+ min_interest_rate_clamp: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1173
+ max_interest_rate_clamp: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1174
+ min_funding_rate_clamp: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1175
+ max_funding_rate_clamp: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1176
+ impact_margin: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1177
+ interest_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1178
1178
  }, "strip", z.ZodTypeAny, {
1179
1179
  is_active: boolean;
1180
- min_tick_size: number;
1181
- min_lot_size: number;
1182
- min_interest_rate_clamp: number;
1183
- max_interest_rate_clamp: number;
1184
- min_funding_rate_clamp: number;
1185
- max_funding_rate_clamp: number;
1186
- impact_margin: number;
1187
- interest_rate: number;
1180
+ min_tick_size: import("decimal.js").Decimal;
1181
+ min_lot_size: import("decimal.js").Decimal;
1182
+ min_interest_rate_clamp: import("decimal.js").Decimal;
1183
+ max_interest_rate_clamp: import("decimal.js").Decimal;
1184
+ min_funding_rate_clamp: import("decimal.js").Decimal;
1185
+ max_funding_rate_clamp: import("decimal.js").Decimal;
1186
+ impact_margin: import("decimal.js").Decimal;
1187
+ interest_rate: import("decimal.js").Decimal;
1188
1188
  }, {
1189
1189
  is_active: boolean;
1190
- min_tick_size: number;
1191
- min_lot_size: number;
1192
- min_interest_rate_clamp: number;
1193
- max_interest_rate_clamp: number;
1194
- min_funding_rate_clamp: number;
1195
- max_funding_rate_clamp: number;
1196
- impact_margin: number;
1197
- interest_rate: number;
1190
+ min_tick_size: string | number;
1191
+ min_lot_size: string | number;
1192
+ min_interest_rate_clamp: string | number;
1193
+ max_interest_rate_clamp: string | number;
1194
+ min_funding_rate_clamp: string | number;
1195
+ max_funding_rate_clamp: string | number;
1196
+ impact_margin: string | number;
1197
+ interest_rate: string | number;
1198
1198
  }>;
1199
1199
  readonly MarginConfig: z.ZodObject<{
1200
1200
  perp_leverage_tables: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
1201
1201
  tiers: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
1202
1202
  max_leverage: z.ZodNumber;
1203
- mmr: z.ZodNumber;
1204
- maintenance_amount: z.ZodNumber;
1203
+ mmr: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1204
+ maintenance_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1205
1205
  }, "strip", z.ZodTypeAny, {
1206
1206
  max_leverage: number;
1207
- mmr: number;
1208
- maintenance_amount: number;
1207
+ mmr: import("decimal.js").Decimal;
1208
+ maintenance_amount: import("decimal.js").Decimal;
1209
1209
  }, {
1210
1210
  max_leverage: number;
1211
- mmr: number;
1212
- maintenance_amount: number;
1213
- }>>, Map<any, {
1211
+ mmr: string | number;
1212
+ maintenance_amount: string | number;
1213
+ }>>, Map<string, {
1214
1214
  max_leverage: number;
1215
- mmr: number;
1216
- maintenance_amount: number;
1215
+ mmr: import("decimal.js").Decimal;
1216
+ maintenance_amount: import("decimal.js").Decimal;
1217
1217
  }>, Record<string, {
1218
1218
  max_leverage: number;
1219
- mmr: number;
1220
- maintenance_amount: number;
1219
+ mmr: string | number;
1220
+ maintenance_amount: string | number;
1221
1221
  }>>;
1222
1222
  }, "strip", z.ZodTypeAny, {
1223
- tiers: Map<any, {
1223
+ tiers: Map<string, {
1224
1224
  max_leverage: number;
1225
- mmr: number;
1226
- maintenance_amount: number;
1225
+ mmr: import("decimal.js").Decimal;
1226
+ maintenance_amount: import("decimal.js").Decimal;
1227
1227
  }>;
1228
1228
  }, {
1229
1229
  tiers: Record<string, {
1230
1230
  max_leverage: number;
1231
- mmr: number;
1232
- maintenance_amount: number;
1231
+ mmr: string | number;
1232
+ maintenance_amount: string | number;
1233
1233
  }>;
1234
- }>>, Map<any, {
1235
- tiers: Map<any, {
1234
+ }>>, Map<number, {
1235
+ tiers: Map<string, {
1236
1236
  max_leverage: number;
1237
- mmr: number;
1238
- maintenance_amount: number;
1237
+ mmr: import("decimal.js").Decimal;
1238
+ maintenance_amount: import("decimal.js").Decimal;
1239
1239
  }>;
1240
1240
  }>, Record<string, {
1241
1241
  tiers: Record<string, {
1242
1242
  max_leverage: number;
1243
- mmr: number;
1244
- maintenance_amount: number;
1243
+ mmr: string | number;
1244
+ maintenance_amount: string | number;
1245
1245
  }>;
1246
1246
  }>>;
1247
- liquidation_ioc_buffer: z.ZodNumber;
1248
- backstop_liquidation_threshold: z.ZodNumber;
1249
- liquidation_fee: z.ZodNumber;
1247
+ liquidation_ioc_buffer: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1248
+ backstop_liquidation_threshold: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1249
+ liquidation_fee: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1250
1250
  }, "strip", z.ZodTypeAny, {
1251
- perp_leverage_tables: Map<any, {
1252
- tiers: Map<any, {
1251
+ perp_leverage_tables: Map<number, {
1252
+ tiers: Map<string, {
1253
1253
  max_leverage: number;
1254
- mmr: number;
1255
- maintenance_amount: number;
1254
+ mmr: import("decimal.js").Decimal;
1255
+ maintenance_amount: import("decimal.js").Decimal;
1256
1256
  }>;
1257
1257
  }>;
1258
- liquidation_ioc_buffer: number;
1259
- backstop_liquidation_threshold: number;
1260
- liquidation_fee: number;
1258
+ liquidation_ioc_buffer: import("decimal.js").Decimal;
1259
+ backstop_liquidation_threshold: import("decimal.js").Decimal;
1260
+ liquidation_fee: import("decimal.js").Decimal;
1261
1261
  }, {
1262
1262
  perp_leverage_tables: Record<string, {
1263
1263
  tiers: Record<string, {
1264
1264
  max_leverage: number;
1265
- mmr: number;
1266
- maintenance_amount: number;
1265
+ mmr: string | number;
1266
+ maintenance_amount: string | number;
1267
1267
  }>;
1268
1268
  }>;
1269
- liquidation_ioc_buffer: number;
1270
- backstop_liquidation_threshold: number;
1271
- liquidation_fee: number;
1269
+ liquidation_ioc_buffer: string | number;
1270
+ backstop_liquidation_threshold: string | number;
1271
+ liquidation_fee: string | number;
1272
1272
  }>;
1273
1273
  readonly Assets: z.ZodObject<{
1274
- assets: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Map<any, string>, Record<string, string>>;
1274
+ assets: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Map<number, string>, Record<string, string>>;
1275
1275
  }, "strip", z.ZodTypeAny, {
1276
- assets: Map<any, string>;
1276
+ assets: Map<number, string>;
1277
1277
  }, {
1278
1278
  assets: Record<string, string>;
1279
1279
  }>;
@@ -1287,12 +1287,12 @@ export declare const ResponseSchemas: {
1287
1287
  }, {
1288
1288
  value: number | null;
1289
1289
  }>;
1290
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
1290
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
1291
1291
  }, "strip", z.ZodTypeAny, {
1292
1292
  data: {
1293
1293
  value: number | null;
1294
1294
  };
1295
- meta?: Map<any, unknown> | undefined;
1295
+ meta?: Map<unknown, unknown> | undefined;
1296
1296
  }, {
1297
1297
  data: {
1298
1298
  value: number | null;
@@ -1301,103 +1301,103 @@ export declare const ResponseSchemas: {
1301
1301
  }>;
1302
1302
  readonly Order: z.ZodObject<{
1303
1303
  data: z.ZodObject<{
1304
- key: z.ZodNumber;
1304
+ key: z.ZodBigInt;
1305
1305
  value: z.ZodNullable<z.ZodObject<{
1306
1306
  side: z.ZodEnum<["Bid", "Ask"]>;
1307
1307
  asset_id: z.ZodNumber;
1308
- order_id: z.ZodNumber;
1309
- price: z.ZodNumber;
1310
- size: z.ZodNumber;
1308
+ order_id: z.ZodBigInt;
1309
+ price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1310
+ size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1311
1311
  reduce_only: z.ZodBoolean;
1312
- filled_size: z.ZodNumber;
1313
- average_filled_price: z.ZodNumber;
1312
+ filled_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1313
+ average_filled_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1314
1314
  owner: z.ZodString;
1315
- tpsl_order_ids: z.ZodArray<z.ZodNumber, "many">;
1315
+ tpsl_order_ids: z.ZodArray<z.ZodBigInt, "many">;
1316
1316
  }, "strip", z.ZodTypeAny, {
1317
- size: number;
1318
- price: number;
1317
+ size: import("decimal.js").Decimal;
1318
+ price: import("decimal.js").Decimal;
1319
1319
  side: "Bid" | "Ask";
1320
- order_id: number;
1320
+ order_id: bigint;
1321
1321
  reduce_only: boolean;
1322
1322
  asset_id: number;
1323
- filled_size: number;
1324
- average_filled_price: number;
1323
+ filled_size: import("decimal.js").Decimal;
1324
+ average_filled_price: import("decimal.js").Decimal;
1325
1325
  owner: string;
1326
- tpsl_order_ids: number[];
1326
+ tpsl_order_ids: bigint[];
1327
1327
  }, {
1328
- size: number;
1329
- price: number;
1328
+ size: string | number;
1329
+ price: string | number;
1330
1330
  side: "Bid" | "Ask";
1331
- order_id: number;
1331
+ order_id: bigint;
1332
1332
  reduce_only: boolean;
1333
1333
  asset_id: number;
1334
- filled_size: number;
1335
- average_filled_price: number;
1334
+ filled_size: string | number;
1335
+ average_filled_price: string | number;
1336
1336
  owner: string;
1337
- tpsl_order_ids: number[];
1337
+ tpsl_order_ids: bigint[];
1338
1338
  }>>;
1339
1339
  }, "strip", z.ZodTypeAny, {
1340
1340
  value: {
1341
- size: number;
1342
- price: number;
1341
+ size: import("decimal.js").Decimal;
1342
+ price: import("decimal.js").Decimal;
1343
1343
  side: "Bid" | "Ask";
1344
- order_id: number;
1344
+ order_id: bigint;
1345
1345
  reduce_only: boolean;
1346
1346
  asset_id: number;
1347
- filled_size: number;
1348
- average_filled_price: number;
1347
+ filled_size: import("decimal.js").Decimal;
1348
+ average_filled_price: import("decimal.js").Decimal;
1349
1349
  owner: string;
1350
- tpsl_order_ids: number[];
1350
+ tpsl_order_ids: bigint[];
1351
1351
  } | null;
1352
- key: number;
1352
+ key: bigint;
1353
1353
  }, {
1354
1354
  value: {
1355
- size: number;
1356
- price: number;
1355
+ size: string | number;
1356
+ price: string | number;
1357
1357
  side: "Bid" | "Ask";
1358
- order_id: number;
1358
+ order_id: bigint;
1359
1359
  reduce_only: boolean;
1360
1360
  asset_id: number;
1361
- filled_size: number;
1362
- average_filled_price: number;
1361
+ filled_size: string | number;
1362
+ average_filled_price: string | number;
1363
1363
  owner: string;
1364
- tpsl_order_ids: number[];
1364
+ tpsl_order_ids: bigint[];
1365
1365
  } | null;
1366
- key: number;
1366
+ key: bigint;
1367
1367
  }>;
1368
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
1368
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
1369
1369
  }, "strip", z.ZodTypeAny, {
1370
1370
  data: {
1371
1371
  value: {
1372
- size: number;
1373
- price: number;
1372
+ size: import("decimal.js").Decimal;
1373
+ price: import("decimal.js").Decimal;
1374
1374
  side: "Bid" | "Ask";
1375
- order_id: number;
1375
+ order_id: bigint;
1376
1376
  reduce_only: boolean;
1377
1377
  asset_id: number;
1378
- filled_size: number;
1379
- average_filled_price: number;
1378
+ filled_size: import("decimal.js").Decimal;
1379
+ average_filled_price: import("decimal.js").Decimal;
1380
1380
  owner: string;
1381
- tpsl_order_ids: number[];
1381
+ tpsl_order_ids: bigint[];
1382
1382
  } | null;
1383
- key: number;
1383
+ key: bigint;
1384
1384
  };
1385
- meta?: Map<any, unknown> | undefined;
1385
+ meta?: Map<unknown, unknown> | undefined;
1386
1386
  }, {
1387
1387
  data: {
1388
1388
  value: {
1389
- size: number;
1390
- price: number;
1389
+ size: string | number;
1390
+ price: string | number;
1391
1391
  side: "Bid" | "Ask";
1392
- order_id: number;
1392
+ order_id: bigint;
1393
1393
  reduce_only: boolean;
1394
1394
  asset_id: number;
1395
- filled_size: number;
1396
- average_filled_price: number;
1395
+ filled_size: string | number;
1396
+ average_filled_price: string | number;
1397
1397
  owner: string;
1398
- tpsl_order_ids: number[];
1398
+ tpsl_order_ids: bigint[];
1399
1399
  } | null;
1400
- key: number;
1400
+ key: bigint;
1401
1401
  };
1402
1402
  meta?: Record<string, unknown> | undefined;
1403
1403
  }>;
@@ -1407,429 +1407,429 @@ export declare const ResponseSchemas: {
1407
1407
  usdc_ledger: z.ZodObject<{
1408
1408
  ledger: z.ZodObject<{
1409
1409
  weights: z.ZodObject<{
1410
- asset_weight: z.ZodNumber;
1411
- initial_liability_weight: z.ZodNumber;
1412
- maintenance_liability_weight: z.ZodNumber;
1410
+ asset_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1411
+ initial_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1412
+ maintenance_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1413
1413
  }, "strip", z.ZodTypeAny, {
1414
- asset_weight: number;
1415
- initial_liability_weight: number;
1416
- maintenance_liability_weight: number;
1414
+ asset_weight: import("decimal.js").Decimal;
1415
+ initial_liability_weight: import("decimal.js").Decimal;
1416
+ maintenance_liability_weight: import("decimal.js").Decimal;
1417
1417
  }, {
1418
- asset_weight: number;
1419
- initial_liability_weight: number;
1420
- maintenance_liability_weight: number;
1418
+ asset_weight: string | number;
1419
+ initial_liability_weight: string | number;
1420
+ maintenance_liability_weight: string | number;
1421
1421
  }>;
1422
- asset: z.ZodNumber;
1423
- liability: z.ZodNumber;
1422
+ asset: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1423
+ liability: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1424
1424
  }, "strip", z.ZodTypeAny, {
1425
1425
  weights: {
1426
- asset_weight: number;
1427
- initial_liability_weight: number;
1428
- maintenance_liability_weight: number;
1426
+ asset_weight: import("decimal.js").Decimal;
1427
+ initial_liability_weight: import("decimal.js").Decimal;
1428
+ maintenance_liability_weight: import("decimal.js").Decimal;
1429
1429
  };
1430
- asset: number;
1431
- liability: number;
1430
+ asset: import("decimal.js").Decimal;
1431
+ liability: import("decimal.js").Decimal;
1432
1432
  }, {
1433
1433
  weights: {
1434
- asset_weight: number;
1435
- initial_liability_weight: number;
1436
- maintenance_liability_weight: number;
1434
+ asset_weight: string | number;
1435
+ initial_liability_weight: string | number;
1436
+ maintenance_liability_weight: string | number;
1437
1437
  };
1438
- asset: number;
1439
- liability: number;
1438
+ asset: string | number;
1439
+ liability: string | number;
1440
1440
  }>;
1441
- unrealized_loss_borrow: z.ZodNumber;
1442
- unsettled_perp_profit: z.ZodNumber;
1441
+ unrealized_loss_borrow: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1442
+ unsettled_perp_profit: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1443
1443
  }, "strip", z.ZodTypeAny, {
1444
1444
  ledger: {
1445
1445
  weights: {
1446
- asset_weight: number;
1447
- initial_liability_weight: number;
1448
- maintenance_liability_weight: number;
1446
+ asset_weight: import("decimal.js").Decimal;
1447
+ initial_liability_weight: import("decimal.js").Decimal;
1448
+ maintenance_liability_weight: import("decimal.js").Decimal;
1449
1449
  };
1450
- asset: number;
1451
- liability: number;
1450
+ asset: import("decimal.js").Decimal;
1451
+ liability: import("decimal.js").Decimal;
1452
1452
  };
1453
- unrealized_loss_borrow: number;
1454
- unsettled_perp_profit: number;
1453
+ unrealized_loss_borrow: import("decimal.js").Decimal;
1454
+ unsettled_perp_profit: import("decimal.js").Decimal;
1455
1455
  }, {
1456
1456
  ledger: {
1457
1457
  weights: {
1458
- asset_weight: number;
1459
- initial_liability_weight: number;
1460
- maintenance_liability_weight: number;
1458
+ asset_weight: string | number;
1459
+ initial_liability_weight: string | number;
1460
+ maintenance_liability_weight: string | number;
1461
1461
  };
1462
- asset: number;
1463
- liability: number;
1462
+ asset: string | number;
1463
+ liability: string | number;
1464
1464
  };
1465
- unrealized_loss_borrow: number;
1466
- unsettled_perp_profit: number;
1465
+ unrealized_loss_borrow: string | number;
1466
+ unsettled_perp_profit: string | number;
1467
1467
  }>;
1468
1468
  spot_ledgers: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
1469
1469
  weights: z.ZodObject<{
1470
- asset_weight: z.ZodNumber;
1471
- initial_liability_weight: z.ZodNumber;
1472
- maintenance_liability_weight: z.ZodNumber;
1470
+ asset_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1471
+ initial_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1472
+ maintenance_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1473
1473
  }, "strip", z.ZodTypeAny, {
1474
- asset_weight: number;
1475
- initial_liability_weight: number;
1476
- maintenance_liability_weight: number;
1474
+ asset_weight: import("decimal.js").Decimal;
1475
+ initial_liability_weight: import("decimal.js").Decimal;
1476
+ maintenance_liability_weight: import("decimal.js").Decimal;
1477
1477
  }, {
1478
- asset_weight: number;
1479
- initial_liability_weight: number;
1480
- maintenance_liability_weight: number;
1478
+ asset_weight: string | number;
1479
+ initial_liability_weight: string | number;
1480
+ maintenance_liability_weight: string | number;
1481
1481
  }>;
1482
- asset: z.ZodNumber;
1483
- liability: z.ZodNumber;
1482
+ asset: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1483
+ liability: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1484
1484
  }, "strip", z.ZodTypeAny, {
1485
1485
  weights: {
1486
- asset_weight: number;
1487
- initial_liability_weight: number;
1488
- maintenance_liability_weight: number;
1486
+ asset_weight: import("decimal.js").Decimal;
1487
+ initial_liability_weight: import("decimal.js").Decimal;
1488
+ maintenance_liability_weight: import("decimal.js").Decimal;
1489
1489
  };
1490
- asset: number;
1491
- liability: number;
1490
+ asset: import("decimal.js").Decimal;
1491
+ liability: import("decimal.js").Decimal;
1492
1492
  }, {
1493
1493
  weights: {
1494
- asset_weight: number;
1495
- initial_liability_weight: number;
1496
- maintenance_liability_weight: number;
1494
+ asset_weight: string | number;
1495
+ initial_liability_weight: string | number;
1496
+ maintenance_liability_weight: string | number;
1497
1497
  };
1498
- asset: number;
1499
- liability: number;
1500
- }>>, Map<any, {
1498
+ asset: string | number;
1499
+ liability: string | number;
1500
+ }>>, Map<number, {
1501
1501
  weights: {
1502
- asset_weight: number;
1503
- initial_liability_weight: number;
1504
- maintenance_liability_weight: number;
1502
+ asset_weight: import("decimal.js").Decimal;
1503
+ initial_liability_weight: import("decimal.js").Decimal;
1504
+ maintenance_liability_weight: import("decimal.js").Decimal;
1505
1505
  };
1506
- asset: number;
1507
- liability: number;
1506
+ asset: import("decimal.js").Decimal;
1507
+ liability: import("decimal.js").Decimal;
1508
1508
  }>, Record<string, {
1509
1509
  weights: {
1510
- asset_weight: number;
1511
- initial_liability_weight: number;
1512
- maintenance_liability_weight: number;
1510
+ asset_weight: string | number;
1511
+ initial_liability_weight: string | number;
1512
+ maintenance_liability_weight: string | number;
1513
1513
  };
1514
- asset: number;
1515
- liability: number;
1514
+ asset: string | number;
1515
+ liability: string | number;
1516
1516
  }>>;
1517
1517
  perp_ledgers: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
1518
1518
  orders: z.ZodArray<z.ZodObject<{
1519
- size: z.ZodNumber;
1520
- price: z.ZodNumber;
1519
+ size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1520
+ price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1521
1521
  side: z.ZodEnum<["Bid", "Ask"]>;
1522
- order_id: z.ZodNumber;
1522
+ order_id: z.ZodBigInt;
1523
1523
  reduce_only: z.ZodBoolean;
1524
1524
  }, "strip", z.ZodTypeAny, {
1525
- size: number;
1526
- price: number;
1525
+ size: import("decimal.js").Decimal;
1526
+ price: import("decimal.js").Decimal;
1527
1527
  side: "Bid" | "Ask";
1528
- order_id: number;
1528
+ order_id: bigint;
1529
1529
  reduce_only: boolean;
1530
1530
  }, {
1531
- size: number;
1532
- price: number;
1531
+ size: string | number;
1532
+ price: string | number;
1533
1533
  side: "Bid" | "Ask";
1534
- order_id: number;
1534
+ order_id: bigint;
1535
1535
  reduce_only: boolean;
1536
1536
  }>, "many">;
1537
1537
  position: z.ZodObject<{
1538
- size: z.ZodNumber;
1539
- cost_of_trades: z.ZodNumber;
1540
- realized_pnl: z.ZodNumber;
1541
- cached_mark_price: z.ZodNumber;
1542
- last_accum_funding_applied_per_lot: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
1543
- funding_payments_on_side: z.ZodNumber;
1544
- funding_payments_on_position: z.ZodNumber;
1538
+ size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1539
+ cost_of_trades: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1540
+ realized_pnl: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1541
+ cached_mark_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1542
+ last_accum_funding_applied_per_lot: z.ZodTuple<[z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>, z.ZodBigInt], null>;
1543
+ funding_payments_on_side: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1544
+ funding_payments_on_position: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1545
1545
  }, "strip", z.ZodTypeAny, {
1546
- size: number;
1547
- cost_of_trades: number;
1548
- realized_pnl: number;
1549
- cached_mark_price: number;
1550
- last_accum_funding_applied_per_lot: [number, number];
1551
- funding_payments_on_side: number;
1552
- funding_payments_on_position: number;
1546
+ size: import("decimal.js").Decimal;
1547
+ cost_of_trades: import("decimal.js").Decimal;
1548
+ realized_pnl: import("decimal.js").Decimal;
1549
+ cached_mark_price: import("decimal.js").Decimal;
1550
+ last_accum_funding_applied_per_lot: [import("decimal.js").Decimal, bigint];
1551
+ funding_payments_on_side: import("decimal.js").Decimal;
1552
+ funding_payments_on_position: import("decimal.js").Decimal;
1553
1553
  }, {
1554
- size: number;
1555
- cost_of_trades: number;
1556
- realized_pnl: number;
1557
- cached_mark_price: number;
1558
- last_accum_funding_applied_per_lot: [number, number];
1559
- funding_payments_on_side: number;
1560
- funding_payments_on_position: number;
1554
+ size: string | number;
1555
+ cost_of_trades: string | number;
1556
+ realized_pnl: string | number;
1557
+ cached_mark_price: string | number;
1558
+ last_accum_funding_applied_per_lot: [string | number, bigint];
1559
+ funding_payments_on_side: string | number;
1560
+ funding_payments_on_position: string | number;
1561
1561
  }>;
1562
1562
  user_selected_max_leverage: z.ZodNumber;
1563
1563
  tpsls: z.ZodArray<z.ZodObject<{
1564
1564
  side: z.ZodEnum<["Bid", "Ask"]>;
1565
- tpsl_order_id: z.ZodNumber;
1566
- order_price: z.ZodNumber;
1567
- trigger_price: z.ZodNumber;
1565
+ tpsl_order_id: z.ZodBigInt;
1566
+ order_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1567
+ trigger_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1568
1568
  trigger_direction: z.ZodEnum<["GreaterThanOrEqual", "LessThanOrEqual"]>;
1569
1569
  tpsl_price_condition: z.ZodEnum<["Mark", "Oracle", "LastTrade"]>;
1570
- active_size: z.ZodNumber;
1571
- full_size: z.ZodNumber;
1570
+ active_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1571
+ full_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
1572
1572
  order_type: z.ZodEnum<["Limit", "PostOnly", "FillOrKill", "ImmediateOrCancel", "PostOnlySlide", "PostOnlyFront"]>;
1573
- parent_order_id: z.ZodOptional<z.ZodNumber>;
1574
- linked_tpsl_order_ids: z.ZodArray<z.ZodNumber, "many">;
1573
+ parent_order_id: z.ZodOptional<z.ZodBigInt>;
1574
+ linked_tpsl_order_ids: z.ZodArray<z.ZodBigInt, "many">;
1575
1575
  }, "strip", z.ZodTypeAny, {
1576
1576
  side: "Bid" | "Ask";
1577
- tpsl_order_id: number;
1578
- order_price: number;
1579
- trigger_price: number;
1577
+ tpsl_order_id: bigint;
1578
+ order_price: import("decimal.js").Decimal;
1579
+ trigger_price: import("decimal.js").Decimal;
1580
1580
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1581
1581
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1582
- active_size: number;
1583
- full_size: number;
1582
+ active_size: import("decimal.js").Decimal;
1583
+ full_size: import("decimal.js").Decimal;
1584
1584
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1585
- linked_tpsl_order_ids: number[];
1586
- parent_order_id?: number | undefined;
1585
+ linked_tpsl_order_ids: bigint[];
1586
+ parent_order_id?: bigint | undefined;
1587
1587
  }, {
1588
1588
  side: "Bid" | "Ask";
1589
- tpsl_order_id: number;
1590
- order_price: number;
1591
- trigger_price: number;
1589
+ tpsl_order_id: bigint;
1590
+ order_price: string | number;
1591
+ trigger_price: string | number;
1592
1592
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1593
1593
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1594
- active_size: number;
1595
- full_size: number;
1594
+ active_size: string | number;
1595
+ full_size: string | number;
1596
1596
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1597
- linked_tpsl_order_ids: number[];
1598
- parent_order_id?: number | undefined;
1597
+ linked_tpsl_order_ids: bigint[];
1598
+ parent_order_id?: bigint | undefined;
1599
1599
  }>, "many">;
1600
1600
  }, "strip", z.ZodTypeAny, {
1601
1601
  orders: {
1602
- size: number;
1603
- price: number;
1602
+ size: import("decimal.js").Decimal;
1603
+ price: import("decimal.js").Decimal;
1604
1604
  side: "Bid" | "Ask";
1605
- order_id: number;
1605
+ order_id: bigint;
1606
1606
  reduce_only: boolean;
1607
1607
  }[];
1608
1608
  position: {
1609
- size: number;
1610
- cost_of_trades: number;
1611
- realized_pnl: number;
1612
- cached_mark_price: number;
1613
- last_accum_funding_applied_per_lot: [number, number];
1614
- funding_payments_on_side: number;
1615
- funding_payments_on_position: number;
1609
+ size: import("decimal.js").Decimal;
1610
+ cost_of_trades: import("decimal.js").Decimal;
1611
+ realized_pnl: import("decimal.js").Decimal;
1612
+ cached_mark_price: import("decimal.js").Decimal;
1613
+ last_accum_funding_applied_per_lot: [import("decimal.js").Decimal, bigint];
1614
+ funding_payments_on_side: import("decimal.js").Decimal;
1615
+ funding_payments_on_position: import("decimal.js").Decimal;
1616
1616
  };
1617
1617
  user_selected_max_leverage: number;
1618
1618
  tpsls: {
1619
1619
  side: "Bid" | "Ask";
1620
- tpsl_order_id: number;
1621
- order_price: number;
1622
- trigger_price: number;
1620
+ tpsl_order_id: bigint;
1621
+ order_price: import("decimal.js").Decimal;
1622
+ trigger_price: import("decimal.js").Decimal;
1623
1623
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1624
1624
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1625
- active_size: number;
1626
- full_size: number;
1625
+ active_size: import("decimal.js").Decimal;
1626
+ full_size: import("decimal.js").Decimal;
1627
1627
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1628
- linked_tpsl_order_ids: number[];
1629
- parent_order_id?: number | undefined;
1628
+ linked_tpsl_order_ids: bigint[];
1629
+ parent_order_id?: bigint | undefined;
1630
1630
  }[];
1631
1631
  }, {
1632
1632
  orders: {
1633
- size: number;
1634
- price: number;
1633
+ size: string | number;
1634
+ price: string | number;
1635
1635
  side: "Bid" | "Ask";
1636
- order_id: number;
1636
+ order_id: bigint;
1637
1637
  reduce_only: boolean;
1638
1638
  }[];
1639
1639
  position: {
1640
- size: number;
1641
- cost_of_trades: number;
1642
- realized_pnl: number;
1643
- cached_mark_price: number;
1644
- last_accum_funding_applied_per_lot: [number, number];
1645
- funding_payments_on_side: number;
1646
- funding_payments_on_position: number;
1640
+ size: string | number;
1641
+ cost_of_trades: string | number;
1642
+ realized_pnl: string | number;
1643
+ cached_mark_price: string | number;
1644
+ last_accum_funding_applied_per_lot: [string | number, bigint];
1645
+ funding_payments_on_side: string | number;
1646
+ funding_payments_on_position: string | number;
1647
1647
  };
1648
1648
  user_selected_max_leverage: number;
1649
1649
  tpsls: {
1650
1650
  side: "Bid" | "Ask";
1651
- tpsl_order_id: number;
1652
- order_price: number;
1653
- trigger_price: number;
1651
+ tpsl_order_id: bigint;
1652
+ order_price: string | number;
1653
+ trigger_price: string | number;
1654
1654
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1655
1655
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1656
- active_size: number;
1657
- full_size: number;
1656
+ active_size: string | number;
1657
+ full_size: string | number;
1658
1658
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1659
- linked_tpsl_order_ids: number[];
1660
- parent_order_id?: number | undefined;
1659
+ linked_tpsl_order_ids: bigint[];
1660
+ parent_order_id?: bigint | undefined;
1661
1661
  }[];
1662
- }>>, Map<any, {
1662
+ }>>, Map<number, {
1663
1663
  orders: {
1664
- size: number;
1665
- price: number;
1664
+ size: import("decimal.js").Decimal;
1665
+ price: import("decimal.js").Decimal;
1666
1666
  side: "Bid" | "Ask";
1667
- order_id: number;
1667
+ order_id: bigint;
1668
1668
  reduce_only: boolean;
1669
1669
  }[];
1670
1670
  position: {
1671
- size: number;
1672
- cost_of_trades: number;
1673
- realized_pnl: number;
1674
- cached_mark_price: number;
1675
- last_accum_funding_applied_per_lot: [number, number];
1676
- funding_payments_on_side: number;
1677
- funding_payments_on_position: number;
1671
+ size: import("decimal.js").Decimal;
1672
+ cost_of_trades: import("decimal.js").Decimal;
1673
+ realized_pnl: import("decimal.js").Decimal;
1674
+ cached_mark_price: import("decimal.js").Decimal;
1675
+ last_accum_funding_applied_per_lot: [import("decimal.js").Decimal, bigint];
1676
+ funding_payments_on_side: import("decimal.js").Decimal;
1677
+ funding_payments_on_position: import("decimal.js").Decimal;
1678
1678
  };
1679
1679
  user_selected_max_leverage: number;
1680
1680
  tpsls: {
1681
1681
  side: "Bid" | "Ask";
1682
- tpsl_order_id: number;
1683
- order_price: number;
1684
- trigger_price: number;
1682
+ tpsl_order_id: bigint;
1683
+ order_price: import("decimal.js").Decimal;
1684
+ trigger_price: import("decimal.js").Decimal;
1685
1685
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1686
1686
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1687
- active_size: number;
1688
- full_size: number;
1687
+ active_size: import("decimal.js").Decimal;
1688
+ full_size: import("decimal.js").Decimal;
1689
1689
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1690
- linked_tpsl_order_ids: number[];
1691
- parent_order_id?: number | undefined;
1690
+ linked_tpsl_order_ids: bigint[];
1691
+ parent_order_id?: bigint | undefined;
1692
1692
  }[];
1693
1693
  }>, Record<string, {
1694
1694
  orders: {
1695
- size: number;
1696
- price: number;
1695
+ size: string | number;
1696
+ price: string | number;
1697
1697
  side: "Bid" | "Ask";
1698
- order_id: number;
1698
+ order_id: bigint;
1699
1699
  reduce_only: boolean;
1700
1700
  }[];
1701
1701
  position: {
1702
- size: number;
1703
- cost_of_trades: number;
1704
- realized_pnl: number;
1705
- cached_mark_price: number;
1706
- last_accum_funding_applied_per_lot: [number, number];
1707
- funding_payments_on_side: number;
1708
- funding_payments_on_position: number;
1702
+ size: string | number;
1703
+ cost_of_trades: string | number;
1704
+ realized_pnl: string | number;
1705
+ cached_mark_price: string | number;
1706
+ last_accum_funding_applied_per_lot: [string | number, bigint];
1707
+ funding_payments_on_side: string | number;
1708
+ funding_payments_on_position: string | number;
1709
1709
  };
1710
1710
  user_selected_max_leverage: number;
1711
1711
  tpsls: {
1712
1712
  side: "Bid" | "Ask";
1713
- tpsl_order_id: number;
1714
- order_price: number;
1715
- trigger_price: number;
1713
+ tpsl_order_id: bigint;
1714
+ order_price: string | number;
1715
+ trigger_price: string | number;
1716
1716
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1717
1717
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1718
- active_size: number;
1719
- full_size: number;
1718
+ active_size: string | number;
1719
+ full_size: string | number;
1720
1720
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1721
- linked_tpsl_order_ids: number[];
1722
- parent_order_id?: number | undefined;
1721
+ linked_tpsl_order_ids: bigint[];
1722
+ parent_order_id?: bigint | undefined;
1723
1723
  }[];
1724
1724
  }>>;
1725
1725
  }, "strip", z.ZodTypeAny, {
1726
1726
  usdc_ledger: {
1727
1727
  ledger: {
1728
1728
  weights: {
1729
- asset_weight: number;
1730
- initial_liability_weight: number;
1731
- maintenance_liability_weight: number;
1729
+ asset_weight: import("decimal.js").Decimal;
1730
+ initial_liability_weight: import("decimal.js").Decimal;
1731
+ maintenance_liability_weight: import("decimal.js").Decimal;
1732
1732
  };
1733
- asset: number;
1734
- liability: number;
1733
+ asset: import("decimal.js").Decimal;
1734
+ liability: import("decimal.js").Decimal;
1735
1735
  };
1736
- unrealized_loss_borrow: number;
1737
- unsettled_perp_profit: number;
1736
+ unrealized_loss_borrow: import("decimal.js").Decimal;
1737
+ unsettled_perp_profit: import("decimal.js").Decimal;
1738
1738
  };
1739
- spot_ledgers: Map<any, {
1739
+ spot_ledgers: Map<number, {
1740
1740
  weights: {
1741
- asset_weight: number;
1742
- initial_liability_weight: number;
1743
- maintenance_liability_weight: number;
1741
+ asset_weight: import("decimal.js").Decimal;
1742
+ initial_liability_weight: import("decimal.js").Decimal;
1743
+ maintenance_liability_weight: import("decimal.js").Decimal;
1744
1744
  };
1745
- asset: number;
1746
- liability: number;
1745
+ asset: import("decimal.js").Decimal;
1746
+ liability: import("decimal.js").Decimal;
1747
1747
  }>;
1748
- perp_ledgers: Map<any, {
1748
+ perp_ledgers: Map<number, {
1749
1749
  orders: {
1750
- size: number;
1751
- price: number;
1750
+ size: import("decimal.js").Decimal;
1751
+ price: import("decimal.js").Decimal;
1752
1752
  side: "Bid" | "Ask";
1753
- order_id: number;
1753
+ order_id: bigint;
1754
1754
  reduce_only: boolean;
1755
1755
  }[];
1756
1756
  position: {
1757
- size: number;
1758
- cost_of_trades: number;
1759
- realized_pnl: number;
1760
- cached_mark_price: number;
1761
- last_accum_funding_applied_per_lot: [number, number];
1762
- funding_payments_on_side: number;
1763
- funding_payments_on_position: number;
1757
+ size: import("decimal.js").Decimal;
1758
+ cost_of_trades: import("decimal.js").Decimal;
1759
+ realized_pnl: import("decimal.js").Decimal;
1760
+ cached_mark_price: import("decimal.js").Decimal;
1761
+ last_accum_funding_applied_per_lot: [import("decimal.js").Decimal, bigint];
1762
+ funding_payments_on_side: import("decimal.js").Decimal;
1763
+ funding_payments_on_position: import("decimal.js").Decimal;
1764
1764
  };
1765
1765
  user_selected_max_leverage: number;
1766
1766
  tpsls: {
1767
1767
  side: "Bid" | "Ask";
1768
- tpsl_order_id: number;
1769
- order_price: number;
1770
- trigger_price: number;
1768
+ tpsl_order_id: bigint;
1769
+ order_price: import("decimal.js").Decimal;
1770
+ trigger_price: import("decimal.js").Decimal;
1771
1771
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1772
1772
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1773
- active_size: number;
1774
- full_size: number;
1773
+ active_size: import("decimal.js").Decimal;
1774
+ full_size: import("decimal.js").Decimal;
1775
1775
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1776
- linked_tpsl_order_ids: number[];
1777
- parent_order_id?: number | undefined;
1776
+ linked_tpsl_order_ids: bigint[];
1777
+ parent_order_id?: bigint | undefined;
1778
1778
  }[];
1779
1779
  }>;
1780
1780
  }, {
1781
1781
  usdc_ledger: {
1782
1782
  ledger: {
1783
1783
  weights: {
1784
- asset_weight: number;
1785
- initial_liability_weight: number;
1786
- maintenance_liability_weight: number;
1784
+ asset_weight: string | number;
1785
+ initial_liability_weight: string | number;
1786
+ maintenance_liability_weight: string | number;
1787
1787
  };
1788
- asset: number;
1789
- liability: number;
1788
+ asset: string | number;
1789
+ liability: string | number;
1790
1790
  };
1791
- unrealized_loss_borrow: number;
1792
- unsettled_perp_profit: number;
1791
+ unrealized_loss_borrow: string | number;
1792
+ unsettled_perp_profit: string | number;
1793
1793
  };
1794
1794
  spot_ledgers: Record<string, {
1795
1795
  weights: {
1796
- asset_weight: number;
1797
- initial_liability_weight: number;
1798
- maintenance_liability_weight: number;
1796
+ asset_weight: string | number;
1797
+ initial_liability_weight: string | number;
1798
+ maintenance_liability_weight: string | number;
1799
1799
  };
1800
- asset: number;
1801
- liability: number;
1800
+ asset: string | number;
1801
+ liability: string | number;
1802
1802
  }>;
1803
1803
  perp_ledgers: Record<string, {
1804
1804
  orders: {
1805
- size: number;
1806
- price: number;
1805
+ size: string | number;
1806
+ price: string | number;
1807
1807
  side: "Bid" | "Ask";
1808
- order_id: number;
1808
+ order_id: bigint;
1809
1809
  reduce_only: boolean;
1810
1810
  }[];
1811
1811
  position: {
1812
- size: number;
1813
- cost_of_trades: number;
1814
- realized_pnl: number;
1815
- cached_mark_price: number;
1816
- last_accum_funding_applied_per_lot: [number, number];
1817
- funding_payments_on_side: number;
1818
- funding_payments_on_position: number;
1812
+ size: string | number;
1813
+ cost_of_trades: string | number;
1814
+ realized_pnl: string | number;
1815
+ cached_mark_price: string | number;
1816
+ last_accum_funding_applied_per_lot: [string | number, bigint];
1817
+ funding_payments_on_side: string | number;
1818
+ funding_payments_on_position: string | number;
1819
1819
  };
1820
1820
  user_selected_max_leverage: number;
1821
1821
  tpsls: {
1822
1822
  side: "Bid" | "Ask";
1823
- tpsl_order_id: number;
1824
- order_price: number;
1825
- trigger_price: number;
1823
+ tpsl_order_id: bigint;
1824
+ order_price: string | number;
1825
+ trigger_price: string | number;
1826
1826
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1827
1827
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1828
- active_size: number;
1829
- full_size: number;
1828
+ active_size: string | number;
1829
+ full_size: string | number;
1830
1830
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1831
- linked_tpsl_order_ids: number[];
1832
- parent_order_id?: number | undefined;
1831
+ linked_tpsl_order_ids: bigint[];
1832
+ parent_order_id?: bigint | undefined;
1833
1833
  }[];
1834
1834
  }>;
1835
1835
  }>, "many">;
@@ -1838,55 +1838,55 @@ export declare const ResponseSchemas: {
1838
1838
  usdc_ledger: {
1839
1839
  ledger: {
1840
1840
  weights: {
1841
- asset_weight: number;
1842
- initial_liability_weight: number;
1843
- maintenance_liability_weight: number;
1841
+ asset_weight: import("decimal.js").Decimal;
1842
+ initial_liability_weight: import("decimal.js").Decimal;
1843
+ maintenance_liability_weight: import("decimal.js").Decimal;
1844
1844
  };
1845
- asset: number;
1846
- liability: number;
1845
+ asset: import("decimal.js").Decimal;
1846
+ liability: import("decimal.js").Decimal;
1847
1847
  };
1848
- unrealized_loss_borrow: number;
1849
- unsettled_perp_profit: number;
1848
+ unrealized_loss_borrow: import("decimal.js").Decimal;
1849
+ unsettled_perp_profit: import("decimal.js").Decimal;
1850
1850
  };
1851
- spot_ledgers: Map<any, {
1851
+ spot_ledgers: Map<number, {
1852
1852
  weights: {
1853
- asset_weight: number;
1854
- initial_liability_weight: number;
1855
- maintenance_liability_weight: number;
1853
+ asset_weight: import("decimal.js").Decimal;
1854
+ initial_liability_weight: import("decimal.js").Decimal;
1855
+ maintenance_liability_weight: import("decimal.js").Decimal;
1856
1856
  };
1857
- asset: number;
1858
- liability: number;
1857
+ asset: import("decimal.js").Decimal;
1858
+ liability: import("decimal.js").Decimal;
1859
1859
  }>;
1860
- perp_ledgers: Map<any, {
1860
+ perp_ledgers: Map<number, {
1861
1861
  orders: {
1862
- size: number;
1863
- price: number;
1862
+ size: import("decimal.js").Decimal;
1863
+ price: import("decimal.js").Decimal;
1864
1864
  side: "Bid" | "Ask";
1865
- order_id: number;
1865
+ order_id: bigint;
1866
1866
  reduce_only: boolean;
1867
1867
  }[];
1868
1868
  position: {
1869
- size: number;
1870
- cost_of_trades: number;
1871
- realized_pnl: number;
1872
- cached_mark_price: number;
1873
- last_accum_funding_applied_per_lot: [number, number];
1874
- funding_payments_on_side: number;
1875
- funding_payments_on_position: number;
1869
+ size: import("decimal.js").Decimal;
1870
+ cost_of_trades: import("decimal.js").Decimal;
1871
+ realized_pnl: import("decimal.js").Decimal;
1872
+ cached_mark_price: import("decimal.js").Decimal;
1873
+ last_accum_funding_applied_per_lot: [import("decimal.js").Decimal, bigint];
1874
+ funding_payments_on_side: import("decimal.js").Decimal;
1875
+ funding_payments_on_position: import("decimal.js").Decimal;
1876
1876
  };
1877
1877
  user_selected_max_leverage: number;
1878
1878
  tpsls: {
1879
1879
  side: "Bid" | "Ask";
1880
- tpsl_order_id: number;
1881
- order_price: number;
1882
- trigger_price: number;
1880
+ tpsl_order_id: bigint;
1881
+ order_price: import("decimal.js").Decimal;
1882
+ trigger_price: import("decimal.js").Decimal;
1883
1883
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1884
1884
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1885
- active_size: number;
1886
- full_size: number;
1885
+ active_size: import("decimal.js").Decimal;
1886
+ full_size: import("decimal.js").Decimal;
1887
1887
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1888
- linked_tpsl_order_ids: number[];
1889
- parent_order_id?: number | undefined;
1888
+ linked_tpsl_order_ids: bigint[];
1889
+ parent_order_id?: bigint | undefined;
1890
1890
  }[];
1891
1891
  }>;
1892
1892
  }[];
@@ -1895,175 +1895,175 @@ export declare const ResponseSchemas: {
1895
1895
  usdc_ledger: {
1896
1896
  ledger: {
1897
1897
  weights: {
1898
- asset_weight: number;
1899
- initial_liability_weight: number;
1900
- maintenance_liability_weight: number;
1898
+ asset_weight: string | number;
1899
+ initial_liability_weight: string | number;
1900
+ maintenance_liability_weight: string | number;
1901
1901
  };
1902
- asset: number;
1903
- liability: number;
1902
+ asset: string | number;
1903
+ liability: string | number;
1904
1904
  };
1905
- unrealized_loss_borrow: number;
1906
- unsettled_perp_profit: number;
1905
+ unrealized_loss_borrow: string | number;
1906
+ unsettled_perp_profit: string | number;
1907
1907
  };
1908
1908
  spot_ledgers: Record<string, {
1909
1909
  weights: {
1910
- asset_weight: number;
1911
- initial_liability_weight: number;
1912
- maintenance_liability_weight: number;
1910
+ asset_weight: string | number;
1911
+ initial_liability_weight: string | number;
1912
+ maintenance_liability_weight: string | number;
1913
1913
  };
1914
- asset: number;
1915
- liability: number;
1914
+ asset: string | number;
1915
+ liability: string | number;
1916
1916
  }>;
1917
1917
  perp_ledgers: Record<string, {
1918
1918
  orders: {
1919
- size: number;
1920
- price: number;
1919
+ size: string | number;
1920
+ price: string | number;
1921
1921
  side: "Bid" | "Ask";
1922
- order_id: number;
1922
+ order_id: bigint;
1923
1923
  reduce_only: boolean;
1924
1924
  }[];
1925
1925
  position: {
1926
- size: number;
1927
- cost_of_trades: number;
1928
- realized_pnl: number;
1929
- cached_mark_price: number;
1930
- last_accum_funding_applied_per_lot: [number, number];
1931
- funding_payments_on_side: number;
1932
- funding_payments_on_position: number;
1926
+ size: string | number;
1927
+ cost_of_trades: string | number;
1928
+ realized_pnl: string | number;
1929
+ cached_mark_price: string | number;
1930
+ last_accum_funding_applied_per_lot: [string | number, bigint];
1931
+ funding_payments_on_side: string | number;
1932
+ funding_payments_on_position: string | number;
1933
1933
  };
1934
1934
  user_selected_max_leverage: number;
1935
1935
  tpsls: {
1936
1936
  side: "Bid" | "Ask";
1937
- tpsl_order_id: number;
1938
- order_price: number;
1939
- trigger_price: number;
1937
+ tpsl_order_id: bigint;
1938
+ order_price: string | number;
1939
+ trigger_price: string | number;
1940
1940
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1941
1941
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1942
- active_size: number;
1943
- full_size: number;
1942
+ active_size: string | number;
1943
+ full_size: string | number;
1944
1944
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1945
- linked_tpsl_order_ids: number[];
1946
- parent_order_id?: number | undefined;
1945
+ linked_tpsl_order_ids: bigint[];
1946
+ parent_order_id?: bigint | undefined;
1947
1947
  }[];
1948
1948
  }>;
1949
1949
  }[];
1950
1950
  }>;
1951
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
1951
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
1952
1952
  }, "strip", z.ZodTypeAny, {
1953
1953
  data: {
1954
1954
  user_accounts: {
1955
1955
  usdc_ledger: {
1956
1956
  ledger: {
1957
1957
  weights: {
1958
- asset_weight: number;
1959
- initial_liability_weight: number;
1960
- maintenance_liability_weight: number;
1958
+ asset_weight: import("decimal.js").Decimal;
1959
+ initial_liability_weight: import("decimal.js").Decimal;
1960
+ maintenance_liability_weight: import("decimal.js").Decimal;
1961
1961
  };
1962
- asset: number;
1963
- liability: number;
1962
+ asset: import("decimal.js").Decimal;
1963
+ liability: import("decimal.js").Decimal;
1964
1964
  };
1965
- unrealized_loss_borrow: number;
1966
- unsettled_perp_profit: number;
1965
+ unrealized_loss_borrow: import("decimal.js").Decimal;
1966
+ unsettled_perp_profit: import("decimal.js").Decimal;
1967
1967
  };
1968
- spot_ledgers: Map<any, {
1968
+ spot_ledgers: Map<number, {
1969
1969
  weights: {
1970
- asset_weight: number;
1971
- initial_liability_weight: number;
1972
- maintenance_liability_weight: number;
1970
+ asset_weight: import("decimal.js").Decimal;
1971
+ initial_liability_weight: import("decimal.js").Decimal;
1972
+ maintenance_liability_weight: import("decimal.js").Decimal;
1973
1973
  };
1974
- asset: number;
1975
- liability: number;
1974
+ asset: import("decimal.js").Decimal;
1975
+ liability: import("decimal.js").Decimal;
1976
1976
  }>;
1977
- perp_ledgers: Map<any, {
1977
+ perp_ledgers: Map<number, {
1978
1978
  orders: {
1979
- size: number;
1980
- price: number;
1979
+ size: import("decimal.js").Decimal;
1980
+ price: import("decimal.js").Decimal;
1981
1981
  side: "Bid" | "Ask";
1982
- order_id: number;
1982
+ order_id: bigint;
1983
1983
  reduce_only: boolean;
1984
1984
  }[];
1985
1985
  position: {
1986
- size: number;
1987
- cost_of_trades: number;
1988
- realized_pnl: number;
1989
- cached_mark_price: number;
1990
- last_accum_funding_applied_per_lot: [number, number];
1991
- funding_payments_on_side: number;
1992
- funding_payments_on_position: number;
1986
+ size: import("decimal.js").Decimal;
1987
+ cost_of_trades: import("decimal.js").Decimal;
1988
+ realized_pnl: import("decimal.js").Decimal;
1989
+ cached_mark_price: import("decimal.js").Decimal;
1990
+ last_accum_funding_applied_per_lot: [import("decimal.js").Decimal, bigint];
1991
+ funding_payments_on_side: import("decimal.js").Decimal;
1992
+ funding_payments_on_position: import("decimal.js").Decimal;
1993
1993
  };
1994
1994
  user_selected_max_leverage: number;
1995
1995
  tpsls: {
1996
1996
  side: "Bid" | "Ask";
1997
- tpsl_order_id: number;
1998
- order_price: number;
1999
- trigger_price: number;
1997
+ tpsl_order_id: bigint;
1998
+ order_price: import("decimal.js").Decimal;
1999
+ trigger_price: import("decimal.js").Decimal;
2000
2000
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
2001
2001
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
2002
- active_size: number;
2003
- full_size: number;
2002
+ active_size: import("decimal.js").Decimal;
2003
+ full_size: import("decimal.js").Decimal;
2004
2004
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
2005
- linked_tpsl_order_ids: number[];
2006
- parent_order_id?: number | undefined;
2005
+ linked_tpsl_order_ids: bigint[];
2006
+ parent_order_id?: bigint | undefined;
2007
2007
  }[];
2008
2008
  }>;
2009
2009
  }[];
2010
2010
  };
2011
- meta?: Map<any, unknown> | undefined;
2011
+ meta?: Map<unknown, unknown> | undefined;
2012
2012
  }, {
2013
2013
  data: {
2014
2014
  user_accounts: {
2015
2015
  usdc_ledger: {
2016
2016
  ledger: {
2017
2017
  weights: {
2018
- asset_weight: number;
2019
- initial_liability_weight: number;
2020
- maintenance_liability_weight: number;
2018
+ asset_weight: string | number;
2019
+ initial_liability_weight: string | number;
2020
+ maintenance_liability_weight: string | number;
2021
2021
  };
2022
- asset: number;
2023
- liability: number;
2022
+ asset: string | number;
2023
+ liability: string | number;
2024
2024
  };
2025
- unrealized_loss_borrow: number;
2026
- unsettled_perp_profit: number;
2025
+ unrealized_loss_borrow: string | number;
2026
+ unsettled_perp_profit: string | number;
2027
2027
  };
2028
2028
  spot_ledgers: Record<string, {
2029
2029
  weights: {
2030
- asset_weight: number;
2031
- initial_liability_weight: number;
2032
- maintenance_liability_weight: number;
2030
+ asset_weight: string | number;
2031
+ initial_liability_weight: string | number;
2032
+ maintenance_liability_weight: string | number;
2033
2033
  };
2034
- asset: number;
2035
- liability: number;
2034
+ asset: string | number;
2035
+ liability: string | number;
2036
2036
  }>;
2037
2037
  perp_ledgers: Record<string, {
2038
2038
  orders: {
2039
- size: number;
2040
- price: number;
2039
+ size: string | number;
2040
+ price: string | number;
2041
2041
  side: "Bid" | "Ask";
2042
- order_id: number;
2042
+ order_id: bigint;
2043
2043
  reduce_only: boolean;
2044
2044
  }[];
2045
2045
  position: {
2046
- size: number;
2047
- cost_of_trades: number;
2048
- realized_pnl: number;
2049
- cached_mark_price: number;
2050
- last_accum_funding_applied_per_lot: [number, number];
2051
- funding_payments_on_side: number;
2052
- funding_payments_on_position: number;
2046
+ size: string | number;
2047
+ cost_of_trades: string | number;
2048
+ realized_pnl: string | number;
2049
+ cached_mark_price: string | number;
2050
+ last_accum_funding_applied_per_lot: [string | number, bigint];
2051
+ funding_payments_on_side: string | number;
2052
+ funding_payments_on_position: string | number;
2053
2053
  };
2054
2054
  user_selected_max_leverage: number;
2055
2055
  tpsls: {
2056
2056
  side: "Bid" | "Ask";
2057
- tpsl_order_id: number;
2058
- order_price: number;
2059
- trigger_price: number;
2057
+ tpsl_order_id: bigint;
2058
+ order_price: string | number;
2059
+ trigger_price: string | number;
2060
2060
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
2061
2061
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
2062
- active_size: number;
2063
- full_size: number;
2062
+ active_size: string | number;
2063
+ full_size: string | number;
2064
2064
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
2065
- linked_tpsl_order_ids: number[];
2066
- parent_order_id?: number | undefined;
2065
+ linked_tpsl_order_ids: bigint[];
2066
+ parent_order_id?: bigint | undefined;
2067
2067
  }[];
2068
2068
  }>;
2069
2069
  }[];
@@ -2076,68 +2076,68 @@ export declare const ResponseSchemas: {
2076
2076
  value: z.ZodNullable<z.ZodObject<{
2077
2077
  asset_id: z.ZodNumber;
2078
2078
  bids: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2079
- order_ids: z.ZodArray<z.ZodNumber, "many">;
2080
- total_size: z.ZodNumber;
2079
+ order_ids: z.ZodArray<z.ZodBigInt, "many">;
2080
+ total_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2081
2081
  }, "strip", z.ZodTypeAny, {
2082
- order_ids: number[];
2083
- total_size: number;
2082
+ order_ids: bigint[];
2083
+ total_size: import("decimal.js").Decimal;
2084
2084
  }, {
2085
- order_ids: number[];
2086
- total_size: number;
2087
- }>>, Map<any, {
2088
- order_ids: number[];
2089
- total_size: number;
2085
+ order_ids: bigint[];
2086
+ total_size: string | number;
2087
+ }>>, Map<string, {
2088
+ order_ids: bigint[];
2089
+ total_size: import("decimal.js").Decimal;
2090
2090
  }>, Record<string, {
2091
- order_ids: number[];
2092
- total_size: number;
2091
+ order_ids: bigint[];
2092
+ total_size: string | number;
2093
2093
  }>>;
2094
2094
  asks: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2095
- order_ids: z.ZodArray<z.ZodNumber, "many">;
2096
- total_size: z.ZodNumber;
2095
+ order_ids: z.ZodArray<z.ZodBigInt, "many">;
2096
+ total_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2097
2097
  }, "strip", z.ZodTypeAny, {
2098
- order_ids: number[];
2099
- total_size: number;
2098
+ order_ids: bigint[];
2099
+ total_size: import("decimal.js").Decimal;
2100
2100
  }, {
2101
- order_ids: number[];
2102
- total_size: number;
2103
- }>>, Map<any, {
2104
- order_ids: number[];
2105
- total_size: number;
2101
+ order_ids: bigint[];
2102
+ total_size: string | number;
2103
+ }>>, Map<string, {
2104
+ order_ids: bigint[];
2105
+ total_size: import("decimal.js").Decimal;
2106
2106
  }>, Record<string, {
2107
- order_ids: number[];
2108
- total_size: number;
2107
+ order_ids: bigint[];
2108
+ total_size: string | number;
2109
2109
  }>>;
2110
2110
  }, "strip", z.ZodTypeAny, {
2111
2111
  asset_id: number;
2112
- bids: Map<any, {
2113
- order_ids: number[];
2114
- total_size: number;
2112
+ bids: Map<string, {
2113
+ order_ids: bigint[];
2114
+ total_size: import("decimal.js").Decimal;
2115
2115
  }>;
2116
- asks: Map<any, {
2117
- order_ids: number[];
2118
- total_size: number;
2116
+ asks: Map<string, {
2117
+ order_ids: bigint[];
2118
+ total_size: import("decimal.js").Decimal;
2119
2119
  }>;
2120
2120
  }, {
2121
2121
  asset_id: number;
2122
2122
  bids: Record<string, {
2123
- order_ids: number[];
2124
- total_size: number;
2123
+ order_ids: bigint[];
2124
+ total_size: string | number;
2125
2125
  }>;
2126
2126
  asks: Record<string, {
2127
- order_ids: number[];
2128
- total_size: number;
2127
+ order_ids: bigint[];
2128
+ total_size: string | number;
2129
2129
  }>;
2130
2130
  }>>;
2131
2131
  }, "strip", z.ZodTypeAny, {
2132
2132
  value: {
2133
2133
  asset_id: number;
2134
- bids: Map<any, {
2135
- order_ids: number[];
2136
- total_size: number;
2134
+ bids: Map<string, {
2135
+ order_ids: bigint[];
2136
+ total_size: import("decimal.js").Decimal;
2137
2137
  }>;
2138
- asks: Map<any, {
2139
- order_ids: number[];
2140
- total_size: number;
2138
+ asks: Map<string, {
2139
+ order_ids: bigint[];
2140
+ total_size: import("decimal.js").Decimal;
2141
2141
  }>;
2142
2142
  } | null;
2143
2143
  key: number;
@@ -2145,44 +2145,44 @@ export declare const ResponseSchemas: {
2145
2145
  value: {
2146
2146
  asset_id: number;
2147
2147
  bids: Record<string, {
2148
- order_ids: number[];
2149
- total_size: number;
2148
+ order_ids: bigint[];
2149
+ total_size: string | number;
2150
2150
  }>;
2151
2151
  asks: Record<string, {
2152
- order_ids: number[];
2153
- total_size: number;
2152
+ order_ids: bigint[];
2153
+ total_size: string | number;
2154
2154
  }>;
2155
2155
  } | null;
2156
2156
  key: number;
2157
2157
  }>;
2158
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
2158
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
2159
2159
  }, "strip", z.ZodTypeAny, {
2160
2160
  data: {
2161
2161
  value: {
2162
2162
  asset_id: number;
2163
- bids: Map<any, {
2164
- order_ids: number[];
2165
- total_size: number;
2163
+ bids: Map<string, {
2164
+ order_ids: bigint[];
2165
+ total_size: import("decimal.js").Decimal;
2166
2166
  }>;
2167
- asks: Map<any, {
2168
- order_ids: number[];
2169
- total_size: number;
2167
+ asks: Map<string, {
2168
+ order_ids: bigint[];
2169
+ total_size: import("decimal.js").Decimal;
2170
2170
  }>;
2171
2171
  } | null;
2172
2172
  key: number;
2173
2173
  };
2174
- meta?: Map<any, unknown> | undefined;
2174
+ meta?: Map<unknown, unknown> | undefined;
2175
2175
  }, {
2176
2176
  data: {
2177
2177
  value: {
2178
2178
  asset_id: number;
2179
2179
  bids: Record<string, {
2180
- order_ids: number[];
2181
- total_size: number;
2180
+ order_ids: bigint[];
2181
+ total_size: string | number;
2182
2182
  }>;
2183
2183
  asks: Record<string, {
2184
- order_ids: number[];
2185
- total_size: number;
2184
+ order_ids: bigint[];
2185
+ total_size: string | number;
2186
2186
  }>;
2187
2187
  } | null;
2188
2188
  key: number;
@@ -2194,147 +2194,147 @@ export declare const ResponseSchemas: {
2194
2194
  value: z.ZodNullable<z.ZodObject<{
2195
2195
  pricing_frequency_seconds: z.ZodNumber;
2196
2196
  prices_info: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2197
- mark_price: z.ZodNumber;
2198
- oracle_price: z.ZodNumber;
2199
- publish_timestamp: z.ZodNumber;
2197
+ mark_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2198
+ oracle_price: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2199
+ publish_timestamp: z.ZodBigInt;
2200
2200
  }, "strip", z.ZodTypeAny, {
2201
- mark_price: number;
2202
- oracle_price: number;
2203
- publish_timestamp: number;
2201
+ mark_price: import("decimal.js").Decimal;
2202
+ oracle_price: import("decimal.js").Decimal;
2203
+ publish_timestamp: bigint;
2204
2204
  }, {
2205
- mark_price: number;
2206
- oracle_price: number;
2207
- publish_timestamp: number;
2208
- }>>, Map<any, {
2209
- mark_price: number;
2210
- oracle_price: number;
2211
- publish_timestamp: number;
2205
+ mark_price: string | number;
2206
+ oracle_price: string | number;
2207
+ publish_timestamp: bigint;
2208
+ }>>, Map<number, {
2209
+ mark_price: import("decimal.js").Decimal;
2210
+ oracle_price: import("decimal.js").Decimal;
2211
+ publish_timestamp: bigint;
2212
2212
  }>, Record<string, {
2213
- mark_price: number;
2214
- oracle_price: number;
2215
- publish_timestamp: number;
2213
+ mark_price: string | number;
2214
+ oracle_price: string | number;
2215
+ publish_timestamp: bigint;
2216
2216
  }>>;
2217
2217
  premium_index: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2218
- weighted_premium_sum: z.ZodNumber;
2219
- duration_sum: z.ZodNumber;
2220
- last_update_timestamp: z.ZodNullable<z.ZodNumber>;
2218
+ weighted_premium_sum: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2219
+ duration_sum: z.ZodBigInt;
2220
+ last_update_timestamp: z.ZodNullable<z.ZodBigInt>;
2221
2221
  }, "strip", z.ZodTypeAny, {
2222
- last_update_timestamp: number | null;
2223
- weighted_premium_sum: number;
2224
- duration_sum: number;
2222
+ last_update_timestamp: bigint | null;
2223
+ weighted_premium_sum: import("decimal.js").Decimal;
2224
+ duration_sum: bigint;
2225
2225
  }, {
2226
- last_update_timestamp: number | null;
2227
- weighted_premium_sum: number;
2228
- duration_sum: number;
2229
- }>>, Map<any, {
2230
- last_update_timestamp: number | null;
2231
- weighted_premium_sum: number;
2232
- duration_sum: number;
2226
+ last_update_timestamp: bigint | null;
2227
+ weighted_premium_sum: string | number;
2228
+ duration_sum: bigint;
2229
+ }>>, Map<number, {
2230
+ last_update_timestamp: bigint | null;
2231
+ weighted_premium_sum: import("decimal.js").Decimal;
2232
+ duration_sum: bigint;
2233
2233
  }>, Record<string, {
2234
- last_update_timestamp: number | null;
2235
- weighted_premium_sum: number;
2236
- duration_sum: number;
2234
+ last_update_timestamp: bigint | null;
2235
+ weighted_premium_sum: string | number;
2236
+ duration_sum: bigint;
2237
2237
  }>>;
2238
- funding_rates: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, Map<any, [number, number]>, Record<string, [number, number]>>;
2239
- accum_funding_per_lot: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, Map<any, [number, number]>, Record<string, [number, number]>>;
2238
+ funding_rates: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>, z.ZodBigInt], null>>, Map<number, [import("decimal.js").Decimal, bigint]>, Record<string, [string | number, bigint]>>;
2239
+ accum_funding_per_lot: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>, z.ZodBigInt], null>>, Map<number, [import("decimal.js").Decimal, bigint]>, Record<string, [string | number, bigint]>>;
2240
2240
  }, "strip", z.ZodTypeAny, {
2241
2241
  pricing_frequency_seconds: number;
2242
- prices_info: Map<any, {
2243
- mark_price: number;
2244
- oracle_price: number;
2245
- publish_timestamp: number;
2242
+ prices_info: Map<number, {
2243
+ mark_price: import("decimal.js").Decimal;
2244
+ oracle_price: import("decimal.js").Decimal;
2245
+ publish_timestamp: bigint;
2246
2246
  }>;
2247
- premium_index: Map<any, {
2248
- last_update_timestamp: number | null;
2249
- weighted_premium_sum: number;
2250
- duration_sum: number;
2247
+ premium_index: Map<number, {
2248
+ last_update_timestamp: bigint | null;
2249
+ weighted_premium_sum: import("decimal.js").Decimal;
2250
+ duration_sum: bigint;
2251
2251
  }>;
2252
- funding_rates: Map<any, [number, number]>;
2253
- accum_funding_per_lot: Map<any, [number, number]>;
2252
+ funding_rates: Map<number, [import("decimal.js").Decimal, bigint]>;
2253
+ accum_funding_per_lot: Map<number, [import("decimal.js").Decimal, bigint]>;
2254
2254
  }, {
2255
2255
  pricing_frequency_seconds: number;
2256
2256
  prices_info: Record<string, {
2257
- mark_price: number;
2258
- oracle_price: number;
2259
- publish_timestamp: number;
2257
+ mark_price: string | number;
2258
+ oracle_price: string | number;
2259
+ publish_timestamp: bigint;
2260
2260
  }>;
2261
2261
  premium_index: Record<string, {
2262
- last_update_timestamp: number | null;
2263
- weighted_premium_sum: number;
2264
- duration_sum: number;
2262
+ last_update_timestamp: bigint | null;
2263
+ weighted_premium_sum: string | number;
2264
+ duration_sum: bigint;
2265
2265
  }>;
2266
- funding_rates: Record<string, [number, number]>;
2267
- accum_funding_per_lot: Record<string, [number, number]>;
2266
+ funding_rates: Record<string, [string | number, bigint]>;
2267
+ accum_funding_per_lot: Record<string, [string | number, bigint]>;
2268
2268
  }>>;
2269
2269
  }, "strip", z.ZodTypeAny, {
2270
2270
  value: {
2271
2271
  pricing_frequency_seconds: number;
2272
- prices_info: Map<any, {
2273
- mark_price: number;
2274
- oracle_price: number;
2275
- publish_timestamp: number;
2272
+ prices_info: Map<number, {
2273
+ mark_price: import("decimal.js").Decimal;
2274
+ oracle_price: import("decimal.js").Decimal;
2275
+ publish_timestamp: bigint;
2276
2276
  }>;
2277
- premium_index: Map<any, {
2278
- last_update_timestamp: number | null;
2279
- weighted_premium_sum: number;
2280
- duration_sum: number;
2277
+ premium_index: Map<number, {
2278
+ last_update_timestamp: bigint | null;
2279
+ weighted_premium_sum: import("decimal.js").Decimal;
2280
+ duration_sum: bigint;
2281
2281
  }>;
2282
- funding_rates: Map<any, [number, number]>;
2283
- accum_funding_per_lot: Map<any, [number, number]>;
2282
+ funding_rates: Map<number, [import("decimal.js").Decimal, bigint]>;
2283
+ accum_funding_per_lot: Map<number, [import("decimal.js").Decimal, bigint]>;
2284
2284
  } | null;
2285
2285
  }, {
2286
2286
  value: {
2287
2287
  pricing_frequency_seconds: number;
2288
2288
  prices_info: Record<string, {
2289
- mark_price: number;
2290
- oracle_price: number;
2291
- publish_timestamp: number;
2289
+ mark_price: string | number;
2290
+ oracle_price: string | number;
2291
+ publish_timestamp: bigint;
2292
2292
  }>;
2293
2293
  premium_index: Record<string, {
2294
- last_update_timestamp: number | null;
2295
- weighted_premium_sum: number;
2296
- duration_sum: number;
2294
+ last_update_timestamp: bigint | null;
2295
+ weighted_premium_sum: string | number;
2296
+ duration_sum: bigint;
2297
2297
  }>;
2298
- funding_rates: Record<string, [number, number]>;
2299
- accum_funding_per_lot: Record<string, [number, number]>;
2298
+ funding_rates: Record<string, [string | number, bigint]>;
2299
+ accum_funding_per_lot: Record<string, [string | number, bigint]>;
2300
2300
  } | null;
2301
2301
  }>;
2302
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
2302
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
2303
2303
  }, "strip", z.ZodTypeAny, {
2304
2304
  data: {
2305
2305
  value: {
2306
2306
  pricing_frequency_seconds: number;
2307
- prices_info: Map<any, {
2308
- mark_price: number;
2309
- oracle_price: number;
2310
- publish_timestamp: number;
2307
+ prices_info: Map<number, {
2308
+ mark_price: import("decimal.js").Decimal;
2309
+ oracle_price: import("decimal.js").Decimal;
2310
+ publish_timestamp: bigint;
2311
2311
  }>;
2312
- premium_index: Map<any, {
2313
- last_update_timestamp: number | null;
2314
- weighted_premium_sum: number;
2315
- duration_sum: number;
2312
+ premium_index: Map<number, {
2313
+ last_update_timestamp: bigint | null;
2314
+ weighted_premium_sum: import("decimal.js").Decimal;
2315
+ duration_sum: bigint;
2316
2316
  }>;
2317
- funding_rates: Map<any, [number, number]>;
2318
- accum_funding_per_lot: Map<any, [number, number]>;
2317
+ funding_rates: Map<number, [import("decimal.js").Decimal, bigint]>;
2318
+ accum_funding_per_lot: Map<number, [import("decimal.js").Decimal, bigint]>;
2319
2319
  } | null;
2320
2320
  };
2321
- meta?: Map<any, unknown> | undefined;
2321
+ meta?: Map<unknown, unknown> | undefined;
2322
2322
  }, {
2323
2323
  data: {
2324
2324
  value: {
2325
2325
  pricing_frequency_seconds: number;
2326
2326
  prices_info: Record<string, {
2327
- mark_price: number;
2328
- oracle_price: number;
2329
- publish_timestamp: number;
2327
+ mark_price: string | number;
2328
+ oracle_price: string | number;
2329
+ publish_timestamp: bigint;
2330
2330
  }>;
2331
2331
  premium_index: Record<string, {
2332
- last_update_timestamp: number | null;
2333
- weighted_premium_sum: number;
2334
- duration_sum: number;
2332
+ last_update_timestamp: bigint | null;
2333
+ weighted_premium_sum: string | number;
2334
+ duration_sum: bigint;
2335
2335
  }>;
2336
- funding_rates: Record<string, [number, number]>;
2337
- accum_funding_per_lot: Record<string, [number, number]>;
2336
+ funding_rates: Record<string, [string | number, bigint]>;
2337
+ accum_funding_per_lot: Record<string, [string | number, bigint]>;
2338
2338
  } | null;
2339
2339
  };
2340
2340
  meta?: Record<string, unknown> | undefined;
@@ -2342,40 +2342,40 @@ export declare const ResponseSchemas: {
2342
2342
  readonly UsdcPnlPool: z.ZodObject<{
2343
2343
  data: z.ZodObject<{
2344
2344
  value: z.ZodNullable<z.ZodObject<{
2345
- usdc_token_amount: z.ZodNumber;
2346
- external_deposits: z.ZodRecord<z.ZodString, z.ZodNumber>;
2345
+ usdc_token_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2346
+ external_deposits: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>>, Map<string, import("decimal.js").Decimal>, Record<string, string | number>>;
2347
2347
  }, "strip", z.ZodTypeAny, {
2348
- usdc_token_amount: number;
2349
- external_deposits: Record<string, number>;
2348
+ usdc_token_amount: import("decimal.js").Decimal;
2349
+ external_deposits: Map<string, import("decimal.js").Decimal>;
2350
2350
  }, {
2351
- usdc_token_amount: number;
2352
- external_deposits: Record<string, number>;
2351
+ usdc_token_amount: string | number;
2352
+ external_deposits: Record<string, string | number>;
2353
2353
  }>>;
2354
2354
  }, "strip", z.ZodTypeAny, {
2355
2355
  value: {
2356
- usdc_token_amount: number;
2357
- external_deposits: Record<string, number>;
2356
+ usdc_token_amount: import("decimal.js").Decimal;
2357
+ external_deposits: Map<string, import("decimal.js").Decimal>;
2358
2358
  } | null;
2359
2359
  }, {
2360
2360
  value: {
2361
- usdc_token_amount: number;
2362
- external_deposits: Record<string, number>;
2361
+ usdc_token_amount: string | number;
2362
+ external_deposits: Record<string, string | number>;
2363
2363
  } | null;
2364
2364
  }>;
2365
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
2365
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
2366
2366
  }, "strip", z.ZodTypeAny, {
2367
2367
  data: {
2368
2368
  value: {
2369
- usdc_token_amount: number;
2370
- external_deposits: Record<string, number>;
2369
+ usdc_token_amount: import("decimal.js").Decimal;
2370
+ external_deposits: Map<string, import("decimal.js").Decimal>;
2371
2371
  } | null;
2372
2372
  };
2373
- meta?: Map<any, unknown> | undefined;
2373
+ meta?: Map<unknown, unknown> | undefined;
2374
2374
  }, {
2375
2375
  data: {
2376
2376
  value: {
2377
- usdc_token_amount: number;
2378
- external_deposits: Record<string, number>;
2377
+ usdc_token_amount: string | number;
2378
+ external_deposits: Record<string, string | number>;
2379
2379
  } | null;
2380
2380
  };
2381
2381
  meta?: Record<string, unknown> | undefined;
@@ -2383,47 +2383,47 @@ export declare const ResponseSchemas: {
2383
2383
  readonly UsdcInsuranceFund: z.ZodObject<{
2384
2384
  data: z.ZodObject<{
2385
2385
  value: z.ZodNullable<z.ZodObject<{
2386
- usdc_token_amount: z.ZodNumber;
2387
- external_deposits: z.ZodRecord<z.ZodString, z.ZodNumber>;
2388
- minimum_usdc_token_amount: z.ZodNumber;
2386
+ usdc_token_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2387
+ external_deposits: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>>, Map<string, import("decimal.js").Decimal>, Record<string, string | number>>;
2388
+ minimum_usdc_token_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2389
2389
  }, "strip", z.ZodTypeAny, {
2390
- usdc_token_amount: number;
2391
- external_deposits: Record<string, number>;
2392
- minimum_usdc_token_amount: number;
2390
+ usdc_token_amount: import("decimal.js").Decimal;
2391
+ external_deposits: Map<string, import("decimal.js").Decimal>;
2392
+ minimum_usdc_token_amount: import("decimal.js").Decimal;
2393
2393
  }, {
2394
- usdc_token_amount: number;
2395
- external_deposits: Record<string, number>;
2396
- minimum_usdc_token_amount: number;
2394
+ usdc_token_amount: string | number;
2395
+ external_deposits: Record<string, string | number>;
2396
+ minimum_usdc_token_amount: string | number;
2397
2397
  }>>;
2398
2398
  }, "strip", z.ZodTypeAny, {
2399
2399
  value: {
2400
- usdc_token_amount: number;
2401
- external_deposits: Record<string, number>;
2402
- minimum_usdc_token_amount: number;
2400
+ usdc_token_amount: import("decimal.js").Decimal;
2401
+ external_deposits: Map<string, import("decimal.js").Decimal>;
2402
+ minimum_usdc_token_amount: import("decimal.js").Decimal;
2403
2403
  } | null;
2404
2404
  }, {
2405
2405
  value: {
2406
- usdc_token_amount: number;
2407
- external_deposits: Record<string, number>;
2408
- minimum_usdc_token_amount: number;
2406
+ usdc_token_amount: string | number;
2407
+ external_deposits: Record<string, string | number>;
2408
+ minimum_usdc_token_amount: string | number;
2409
2409
  } | null;
2410
2410
  }>;
2411
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
2411
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
2412
2412
  }, "strip", z.ZodTypeAny, {
2413
2413
  data: {
2414
2414
  value: {
2415
- usdc_token_amount: number;
2416
- external_deposits: Record<string, number>;
2417
- minimum_usdc_token_amount: number;
2415
+ usdc_token_amount: import("decimal.js").Decimal;
2416
+ external_deposits: Map<string, import("decimal.js").Decimal>;
2417
+ minimum_usdc_token_amount: import("decimal.js").Decimal;
2418
2418
  } | null;
2419
2419
  };
2420
- meta?: Map<any, unknown> | undefined;
2420
+ meta?: Map<unknown, unknown> | undefined;
2421
2421
  }, {
2422
2422
  data: {
2423
2423
  value: {
2424
- usdc_token_amount: number;
2425
- external_deposits: Record<string, number>;
2426
- minimum_usdc_token_amount: number;
2424
+ usdc_token_amount: string | number;
2425
+ external_deposits: Record<string, string | number>;
2426
+ minimum_usdc_token_amount: string | number;
2427
2427
  } | null;
2428
2428
  };
2429
2429
  meta?: Record<string, unknown> | undefined;
@@ -2433,324 +2433,324 @@ export declare const ResponseSchemas: {
2433
2433
  market: z.ZodObject<{
2434
2434
  market: z.ZodObject<{
2435
2435
  is_active: z.ZodBoolean;
2436
- last_update_timestamp: z.ZodNumber;
2436
+ last_update_timestamp: z.ZodBigInt;
2437
2437
  decimals: z.ZodNumber;
2438
2438
  risk_params: z.ZodObject<{
2439
2439
  weights: z.ZodObject<{
2440
- asset_weight: z.ZodNumber;
2441
- initial_liability_weight: z.ZodNumber;
2442
- maintenance_liability_weight: z.ZodNumber;
2440
+ asset_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2441
+ initial_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2442
+ maintenance_liability_weight: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2443
2443
  }, "strip", z.ZodTypeAny, {
2444
- asset_weight: number;
2445
- initial_liability_weight: number;
2446
- maintenance_liability_weight: number;
2444
+ asset_weight: import("decimal.js").Decimal;
2445
+ initial_liability_weight: import("decimal.js").Decimal;
2446
+ maintenance_liability_weight: import("decimal.js").Decimal;
2447
2447
  }, {
2448
- asset_weight: number;
2449
- initial_liability_weight: number;
2450
- maintenance_liability_weight: number;
2448
+ asset_weight: string | number;
2449
+ initial_liability_weight: string | number;
2450
+ maintenance_liability_weight: string | number;
2451
2451
  }>;
2452
- deposit_limit: z.ZodNumber;
2453
- borrow_limit: z.ZodNumber;
2454
- liquidation_reward_ratio: z.ZodNumber;
2455
- liability_liquidation_limit_ratio: z.ZodNumber;
2452
+ deposit_limit: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2453
+ borrow_limit: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2454
+ liquidation_reward_ratio: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2455
+ liability_liquidation_limit_ratio: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2456
2456
  }, "strip", z.ZodTypeAny, {
2457
2457
  weights: {
2458
- asset_weight: number;
2459
- initial_liability_weight: number;
2460
- maintenance_liability_weight: number;
2458
+ asset_weight: import("decimal.js").Decimal;
2459
+ initial_liability_weight: import("decimal.js").Decimal;
2460
+ maintenance_liability_weight: import("decimal.js").Decimal;
2461
2461
  };
2462
- deposit_limit: number;
2463
- borrow_limit: number;
2464
- liquidation_reward_ratio: number;
2465
- liability_liquidation_limit_ratio: number;
2462
+ deposit_limit: import("decimal.js").Decimal;
2463
+ borrow_limit: import("decimal.js").Decimal;
2464
+ liquidation_reward_ratio: import("decimal.js").Decimal;
2465
+ liability_liquidation_limit_ratio: import("decimal.js").Decimal;
2466
2466
  }, {
2467
2467
  weights: {
2468
- asset_weight: number;
2469
- initial_liability_weight: number;
2470
- maintenance_liability_weight: number;
2468
+ asset_weight: string | number;
2469
+ initial_liability_weight: string | number;
2470
+ maintenance_liability_weight: string | number;
2471
2471
  };
2472
- deposit_limit: number;
2473
- borrow_limit: number;
2474
- liquidation_reward_ratio: number;
2475
- liability_liquidation_limit_ratio: number;
2472
+ deposit_limit: string | number;
2473
+ borrow_limit: string | number;
2474
+ liquidation_reward_ratio: string | number;
2475
+ liability_liquidation_limit_ratio: string | number;
2476
2476
  }>;
2477
2477
  rate_params: z.ZodObject<{
2478
- optimal_utilisation_rate: z.ZodNumber;
2479
- min_borrow_rate: z.ZodNumber;
2480
- optimal_borrow_rate: z.ZodNumber;
2481
- max_borrow_rate: z.ZodNumber;
2478
+ optimal_utilisation_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2479
+ min_borrow_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2480
+ optimal_borrow_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2481
+ max_borrow_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2482
2482
  }, "strip", z.ZodTypeAny, {
2483
- optimal_utilisation_rate: number;
2484
- min_borrow_rate: number;
2485
- optimal_borrow_rate: number;
2486
- max_borrow_rate: number;
2483
+ optimal_utilisation_rate: import("decimal.js").Decimal;
2484
+ min_borrow_rate: import("decimal.js").Decimal;
2485
+ optimal_borrow_rate: import("decimal.js").Decimal;
2486
+ max_borrow_rate: import("decimal.js").Decimal;
2487
2487
  }, {
2488
- optimal_utilisation_rate: number;
2489
- min_borrow_rate: number;
2490
- optimal_borrow_rate: number;
2491
- max_borrow_rate: number;
2488
+ optimal_utilisation_rate: string | number;
2489
+ min_borrow_rate: string | number;
2490
+ optimal_borrow_rate: string | number;
2491
+ max_borrow_rate: string | number;
2492
2492
  }>;
2493
- available_amount: z.ZodNumber;
2494
- borrowed_amount: z.ZodNumber;
2495
- cumulative_deposit_rate: z.ZodNumber;
2496
- cumulative_borrow_rate: z.ZodNumber;
2497
- accumulated_protocol_fees: z.ZodNumber;
2493
+ available_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2494
+ borrowed_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2495
+ cumulative_deposit_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2496
+ cumulative_borrow_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2497
+ accumulated_protocol_fees: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2498
2498
  }, "strip", z.ZodTypeAny, {
2499
2499
  is_active: boolean;
2500
- last_update_timestamp: number;
2500
+ last_update_timestamp: bigint;
2501
2501
  decimals: number;
2502
2502
  risk_params: {
2503
2503
  weights: {
2504
- asset_weight: number;
2505
- initial_liability_weight: number;
2506
- maintenance_liability_weight: number;
2504
+ asset_weight: import("decimal.js").Decimal;
2505
+ initial_liability_weight: import("decimal.js").Decimal;
2506
+ maintenance_liability_weight: import("decimal.js").Decimal;
2507
2507
  };
2508
- deposit_limit: number;
2509
- borrow_limit: number;
2510
- liquidation_reward_ratio: number;
2511
- liability_liquidation_limit_ratio: number;
2508
+ deposit_limit: import("decimal.js").Decimal;
2509
+ borrow_limit: import("decimal.js").Decimal;
2510
+ liquidation_reward_ratio: import("decimal.js").Decimal;
2511
+ liability_liquidation_limit_ratio: import("decimal.js").Decimal;
2512
2512
  };
2513
2513
  rate_params: {
2514
- optimal_utilisation_rate: number;
2515
- min_borrow_rate: number;
2516
- optimal_borrow_rate: number;
2517
- max_borrow_rate: number;
2514
+ optimal_utilisation_rate: import("decimal.js").Decimal;
2515
+ min_borrow_rate: import("decimal.js").Decimal;
2516
+ optimal_borrow_rate: import("decimal.js").Decimal;
2517
+ max_borrow_rate: import("decimal.js").Decimal;
2518
2518
  };
2519
- available_amount: number;
2520
- borrowed_amount: number;
2521
- cumulative_deposit_rate: number;
2522
- cumulative_borrow_rate: number;
2523
- accumulated_protocol_fees: number;
2519
+ available_amount: import("decimal.js").Decimal;
2520
+ borrowed_amount: import("decimal.js").Decimal;
2521
+ cumulative_deposit_rate: import("decimal.js").Decimal;
2522
+ cumulative_borrow_rate: import("decimal.js").Decimal;
2523
+ accumulated_protocol_fees: import("decimal.js").Decimal;
2524
2524
  }, {
2525
2525
  is_active: boolean;
2526
- last_update_timestamp: number;
2526
+ last_update_timestamp: bigint;
2527
2527
  decimals: number;
2528
2528
  risk_params: {
2529
2529
  weights: {
2530
- asset_weight: number;
2531
- initial_liability_weight: number;
2532
- maintenance_liability_weight: number;
2530
+ asset_weight: string | number;
2531
+ initial_liability_weight: string | number;
2532
+ maintenance_liability_weight: string | number;
2533
2533
  };
2534
- deposit_limit: number;
2535
- borrow_limit: number;
2536
- liquidation_reward_ratio: number;
2537
- liability_liquidation_limit_ratio: number;
2534
+ deposit_limit: string | number;
2535
+ borrow_limit: string | number;
2536
+ liquidation_reward_ratio: string | number;
2537
+ liability_liquidation_limit_ratio: string | number;
2538
2538
  };
2539
2539
  rate_params: {
2540
- optimal_utilisation_rate: number;
2541
- min_borrow_rate: number;
2542
- optimal_borrow_rate: number;
2543
- max_borrow_rate: number;
2540
+ optimal_utilisation_rate: string | number;
2541
+ min_borrow_rate: string | number;
2542
+ optimal_borrow_rate: string | number;
2543
+ max_borrow_rate: string | number;
2544
2544
  };
2545
- available_amount: number;
2546
- borrowed_amount: number;
2547
- cumulative_deposit_rate: number;
2548
- cumulative_borrow_rate: number;
2549
- accumulated_protocol_fees: number;
2545
+ available_amount: string | number;
2546
+ borrowed_amount: string | number;
2547
+ cumulative_deposit_rate: string | number;
2548
+ cumulative_borrow_rate: string | number;
2549
+ accumulated_protocol_fees: string | number;
2550
2550
  }>;
2551
- utilisation_rate: z.ZodNumber;
2552
- current_deposit_rate: z.ZodNumber;
2553
- current_borrow_rate: z.ZodNumber;
2551
+ utilisation_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2552
+ current_deposit_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2553
+ current_borrow_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2554
2554
  }, "strip", z.ZodTypeAny, {
2555
2555
  market: {
2556
2556
  is_active: boolean;
2557
- last_update_timestamp: number;
2557
+ last_update_timestamp: bigint;
2558
2558
  decimals: number;
2559
2559
  risk_params: {
2560
2560
  weights: {
2561
- asset_weight: number;
2562
- initial_liability_weight: number;
2563
- maintenance_liability_weight: number;
2561
+ asset_weight: import("decimal.js").Decimal;
2562
+ initial_liability_weight: import("decimal.js").Decimal;
2563
+ maintenance_liability_weight: import("decimal.js").Decimal;
2564
2564
  };
2565
- deposit_limit: number;
2566
- borrow_limit: number;
2567
- liquidation_reward_ratio: number;
2568
- liability_liquidation_limit_ratio: number;
2565
+ deposit_limit: import("decimal.js").Decimal;
2566
+ borrow_limit: import("decimal.js").Decimal;
2567
+ liquidation_reward_ratio: import("decimal.js").Decimal;
2568
+ liability_liquidation_limit_ratio: import("decimal.js").Decimal;
2569
2569
  };
2570
2570
  rate_params: {
2571
- optimal_utilisation_rate: number;
2572
- min_borrow_rate: number;
2573
- optimal_borrow_rate: number;
2574
- max_borrow_rate: number;
2571
+ optimal_utilisation_rate: import("decimal.js").Decimal;
2572
+ min_borrow_rate: import("decimal.js").Decimal;
2573
+ optimal_borrow_rate: import("decimal.js").Decimal;
2574
+ max_borrow_rate: import("decimal.js").Decimal;
2575
2575
  };
2576
- available_amount: number;
2577
- borrowed_amount: number;
2578
- cumulative_deposit_rate: number;
2579
- cumulative_borrow_rate: number;
2580
- accumulated_protocol_fees: number;
2576
+ available_amount: import("decimal.js").Decimal;
2577
+ borrowed_amount: import("decimal.js").Decimal;
2578
+ cumulative_deposit_rate: import("decimal.js").Decimal;
2579
+ cumulative_borrow_rate: import("decimal.js").Decimal;
2580
+ accumulated_protocol_fees: import("decimal.js").Decimal;
2581
2581
  };
2582
- utilisation_rate: number;
2583
- current_deposit_rate: number;
2584
- current_borrow_rate: number;
2582
+ utilisation_rate: import("decimal.js").Decimal;
2583
+ current_deposit_rate: import("decimal.js").Decimal;
2584
+ current_borrow_rate: import("decimal.js").Decimal;
2585
2585
  }, {
2586
2586
  market: {
2587
2587
  is_active: boolean;
2588
- last_update_timestamp: number;
2588
+ last_update_timestamp: bigint;
2589
2589
  decimals: number;
2590
2590
  risk_params: {
2591
2591
  weights: {
2592
- asset_weight: number;
2593
- initial_liability_weight: number;
2594
- maintenance_liability_weight: number;
2592
+ asset_weight: string | number;
2593
+ initial_liability_weight: string | number;
2594
+ maintenance_liability_weight: string | number;
2595
2595
  };
2596
- deposit_limit: number;
2597
- borrow_limit: number;
2598
- liquidation_reward_ratio: number;
2599
- liability_liquidation_limit_ratio: number;
2596
+ deposit_limit: string | number;
2597
+ borrow_limit: string | number;
2598
+ liquidation_reward_ratio: string | number;
2599
+ liability_liquidation_limit_ratio: string | number;
2600
2600
  };
2601
2601
  rate_params: {
2602
- optimal_utilisation_rate: number;
2603
- min_borrow_rate: number;
2604
- optimal_borrow_rate: number;
2605
- max_borrow_rate: number;
2602
+ optimal_utilisation_rate: string | number;
2603
+ min_borrow_rate: string | number;
2604
+ optimal_borrow_rate: string | number;
2605
+ max_borrow_rate: string | number;
2606
2606
  };
2607
- available_amount: number;
2608
- borrowed_amount: number;
2609
- cumulative_deposit_rate: number;
2610
- cumulative_borrow_rate: number;
2611
- accumulated_protocol_fees: number;
2607
+ available_amount: string | number;
2608
+ borrowed_amount: string | number;
2609
+ cumulative_deposit_rate: string | number;
2610
+ cumulative_borrow_rate: string | number;
2611
+ accumulated_protocol_fees: string | number;
2612
2612
  };
2613
- utilisation_rate: number;
2614
- current_deposit_rate: number;
2615
- current_borrow_rate: number;
2613
+ utilisation_rate: string | number;
2614
+ current_deposit_rate: string | number;
2615
+ current_borrow_rate: string | number;
2616
2616
  }>;
2617
2617
  }, "strip", z.ZodTypeAny, {
2618
2618
  market: {
2619
2619
  market: {
2620
2620
  is_active: boolean;
2621
- last_update_timestamp: number;
2621
+ last_update_timestamp: bigint;
2622
2622
  decimals: number;
2623
2623
  risk_params: {
2624
2624
  weights: {
2625
- asset_weight: number;
2626
- initial_liability_weight: number;
2627
- maintenance_liability_weight: number;
2625
+ asset_weight: import("decimal.js").Decimal;
2626
+ initial_liability_weight: import("decimal.js").Decimal;
2627
+ maintenance_liability_weight: import("decimal.js").Decimal;
2628
2628
  };
2629
- deposit_limit: number;
2630
- borrow_limit: number;
2631
- liquidation_reward_ratio: number;
2632
- liability_liquidation_limit_ratio: number;
2629
+ deposit_limit: import("decimal.js").Decimal;
2630
+ borrow_limit: import("decimal.js").Decimal;
2631
+ liquidation_reward_ratio: import("decimal.js").Decimal;
2632
+ liability_liquidation_limit_ratio: import("decimal.js").Decimal;
2633
2633
  };
2634
2634
  rate_params: {
2635
- optimal_utilisation_rate: number;
2636
- min_borrow_rate: number;
2637
- optimal_borrow_rate: number;
2638
- max_borrow_rate: number;
2635
+ optimal_utilisation_rate: import("decimal.js").Decimal;
2636
+ min_borrow_rate: import("decimal.js").Decimal;
2637
+ optimal_borrow_rate: import("decimal.js").Decimal;
2638
+ max_borrow_rate: import("decimal.js").Decimal;
2639
2639
  };
2640
- available_amount: number;
2641
- borrowed_amount: number;
2642
- cumulative_deposit_rate: number;
2643
- cumulative_borrow_rate: number;
2644
- accumulated_protocol_fees: number;
2640
+ available_amount: import("decimal.js").Decimal;
2641
+ borrowed_amount: import("decimal.js").Decimal;
2642
+ cumulative_deposit_rate: import("decimal.js").Decimal;
2643
+ cumulative_borrow_rate: import("decimal.js").Decimal;
2644
+ accumulated_protocol_fees: import("decimal.js").Decimal;
2645
2645
  };
2646
- utilisation_rate: number;
2647
- current_deposit_rate: number;
2648
- current_borrow_rate: number;
2646
+ utilisation_rate: import("decimal.js").Decimal;
2647
+ current_deposit_rate: import("decimal.js").Decimal;
2648
+ current_borrow_rate: import("decimal.js").Decimal;
2649
2649
  };
2650
2650
  }, {
2651
2651
  market: {
2652
2652
  market: {
2653
2653
  is_active: boolean;
2654
- last_update_timestamp: number;
2654
+ last_update_timestamp: bigint;
2655
2655
  decimals: number;
2656
2656
  risk_params: {
2657
2657
  weights: {
2658
- asset_weight: number;
2659
- initial_liability_weight: number;
2660
- maintenance_liability_weight: number;
2658
+ asset_weight: string | number;
2659
+ initial_liability_weight: string | number;
2660
+ maintenance_liability_weight: string | number;
2661
2661
  };
2662
- deposit_limit: number;
2663
- borrow_limit: number;
2664
- liquidation_reward_ratio: number;
2665
- liability_liquidation_limit_ratio: number;
2662
+ deposit_limit: string | number;
2663
+ borrow_limit: string | number;
2664
+ liquidation_reward_ratio: string | number;
2665
+ liability_liquidation_limit_ratio: string | number;
2666
2666
  };
2667
2667
  rate_params: {
2668
- optimal_utilisation_rate: number;
2669
- min_borrow_rate: number;
2670
- optimal_borrow_rate: number;
2671
- max_borrow_rate: number;
2668
+ optimal_utilisation_rate: string | number;
2669
+ min_borrow_rate: string | number;
2670
+ optimal_borrow_rate: string | number;
2671
+ max_borrow_rate: string | number;
2672
2672
  };
2673
- available_amount: number;
2674
- borrowed_amount: number;
2675
- cumulative_deposit_rate: number;
2676
- cumulative_borrow_rate: number;
2677
- accumulated_protocol_fees: number;
2673
+ available_amount: string | number;
2674
+ borrowed_amount: string | number;
2675
+ cumulative_deposit_rate: string | number;
2676
+ cumulative_borrow_rate: string | number;
2677
+ accumulated_protocol_fees: string | number;
2678
2678
  };
2679
- utilisation_rate: number;
2680
- current_deposit_rate: number;
2681
- current_borrow_rate: number;
2679
+ utilisation_rate: string | number;
2680
+ current_deposit_rate: string | number;
2681
+ current_borrow_rate: string | number;
2682
2682
  };
2683
2683
  }>;
2684
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
2684
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
2685
2685
  }, "strip", z.ZodTypeAny, {
2686
2686
  data: {
2687
2687
  market: {
2688
2688
  market: {
2689
2689
  is_active: boolean;
2690
- last_update_timestamp: number;
2690
+ last_update_timestamp: bigint;
2691
2691
  decimals: number;
2692
2692
  risk_params: {
2693
2693
  weights: {
2694
- asset_weight: number;
2695
- initial_liability_weight: number;
2696
- maintenance_liability_weight: number;
2694
+ asset_weight: import("decimal.js").Decimal;
2695
+ initial_liability_weight: import("decimal.js").Decimal;
2696
+ maintenance_liability_weight: import("decimal.js").Decimal;
2697
2697
  };
2698
- deposit_limit: number;
2699
- borrow_limit: number;
2700
- liquidation_reward_ratio: number;
2701
- liability_liquidation_limit_ratio: number;
2698
+ deposit_limit: import("decimal.js").Decimal;
2699
+ borrow_limit: import("decimal.js").Decimal;
2700
+ liquidation_reward_ratio: import("decimal.js").Decimal;
2701
+ liability_liquidation_limit_ratio: import("decimal.js").Decimal;
2702
2702
  };
2703
2703
  rate_params: {
2704
- optimal_utilisation_rate: number;
2705
- min_borrow_rate: number;
2706
- optimal_borrow_rate: number;
2707
- max_borrow_rate: number;
2704
+ optimal_utilisation_rate: import("decimal.js").Decimal;
2705
+ min_borrow_rate: import("decimal.js").Decimal;
2706
+ optimal_borrow_rate: import("decimal.js").Decimal;
2707
+ max_borrow_rate: import("decimal.js").Decimal;
2708
2708
  };
2709
- available_amount: number;
2710
- borrowed_amount: number;
2711
- cumulative_deposit_rate: number;
2712
- cumulative_borrow_rate: number;
2713
- accumulated_protocol_fees: number;
2709
+ available_amount: import("decimal.js").Decimal;
2710
+ borrowed_amount: import("decimal.js").Decimal;
2711
+ cumulative_deposit_rate: import("decimal.js").Decimal;
2712
+ cumulative_borrow_rate: import("decimal.js").Decimal;
2713
+ accumulated_protocol_fees: import("decimal.js").Decimal;
2714
2714
  };
2715
- utilisation_rate: number;
2716
- current_deposit_rate: number;
2717
- current_borrow_rate: number;
2715
+ utilisation_rate: import("decimal.js").Decimal;
2716
+ current_deposit_rate: import("decimal.js").Decimal;
2717
+ current_borrow_rate: import("decimal.js").Decimal;
2718
2718
  };
2719
2719
  };
2720
- meta?: Map<any, unknown> | undefined;
2720
+ meta?: Map<unknown, unknown> | undefined;
2721
2721
  }, {
2722
2722
  data: {
2723
2723
  market: {
2724
2724
  market: {
2725
2725
  is_active: boolean;
2726
- last_update_timestamp: number;
2726
+ last_update_timestamp: bigint;
2727
2727
  decimals: number;
2728
2728
  risk_params: {
2729
2729
  weights: {
2730
- asset_weight: number;
2731
- initial_liability_weight: number;
2732
- maintenance_liability_weight: number;
2730
+ asset_weight: string | number;
2731
+ initial_liability_weight: string | number;
2732
+ maintenance_liability_weight: string | number;
2733
2733
  };
2734
- deposit_limit: number;
2735
- borrow_limit: number;
2736
- liquidation_reward_ratio: number;
2737
- liability_liquidation_limit_ratio: number;
2734
+ deposit_limit: string | number;
2735
+ borrow_limit: string | number;
2736
+ liquidation_reward_ratio: string | number;
2737
+ liability_liquidation_limit_ratio: string | number;
2738
2738
  };
2739
2739
  rate_params: {
2740
- optimal_utilisation_rate: number;
2741
- min_borrow_rate: number;
2742
- optimal_borrow_rate: number;
2743
- max_borrow_rate: number;
2740
+ optimal_utilisation_rate: string | number;
2741
+ min_borrow_rate: string | number;
2742
+ optimal_borrow_rate: string | number;
2743
+ max_borrow_rate: string | number;
2744
2744
  };
2745
- available_amount: number;
2746
- borrowed_amount: number;
2747
- cumulative_deposit_rate: number;
2748
- cumulative_borrow_rate: number;
2749
- accumulated_protocol_fees: number;
2745
+ available_amount: string | number;
2746
+ borrowed_amount: string | number;
2747
+ cumulative_deposit_rate: string | number;
2748
+ cumulative_borrow_rate: string | number;
2749
+ accumulated_protocol_fees: string | number;
2750
2750
  };
2751
- utilisation_rate: number;
2752
- current_deposit_rate: number;
2753
- current_borrow_rate: number;
2751
+ utilisation_rate: string | number;
2752
+ current_deposit_rate: string | number;
2753
+ current_borrow_rate: string | number;
2754
2754
  };
2755
2755
  };
2756
2756
  meta?: Record<string, unknown> | undefined;
@@ -2760,91 +2760,91 @@ export declare const ResponseSchemas: {
2760
2760
  key: z.ZodNumber;
2761
2761
  value: z.ZodNullable<z.ZodObject<{
2762
2762
  is_active: z.ZodBoolean;
2763
- min_tick_size: z.ZodNumber;
2764
- min_lot_size: z.ZodNumber;
2765
- min_interest_rate_clamp: z.ZodNumber;
2766
- max_interest_rate_clamp: z.ZodNumber;
2767
- min_funding_rate_clamp: z.ZodNumber;
2768
- max_funding_rate_clamp: z.ZodNumber;
2769
- impact_margin: z.ZodNumber;
2770
- interest_rate: z.ZodNumber;
2763
+ min_tick_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2764
+ min_lot_size: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2765
+ min_interest_rate_clamp: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2766
+ max_interest_rate_clamp: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2767
+ min_funding_rate_clamp: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2768
+ max_funding_rate_clamp: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2769
+ impact_margin: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2770
+ interest_rate: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2771
2771
  }, "strip", z.ZodTypeAny, {
2772
2772
  is_active: boolean;
2773
- min_tick_size: number;
2774
- min_lot_size: number;
2775
- min_interest_rate_clamp: number;
2776
- max_interest_rate_clamp: number;
2777
- min_funding_rate_clamp: number;
2778
- max_funding_rate_clamp: number;
2779
- impact_margin: number;
2780
- interest_rate: number;
2773
+ min_tick_size: import("decimal.js").Decimal;
2774
+ min_lot_size: import("decimal.js").Decimal;
2775
+ min_interest_rate_clamp: import("decimal.js").Decimal;
2776
+ max_interest_rate_clamp: import("decimal.js").Decimal;
2777
+ min_funding_rate_clamp: import("decimal.js").Decimal;
2778
+ max_funding_rate_clamp: import("decimal.js").Decimal;
2779
+ impact_margin: import("decimal.js").Decimal;
2780
+ interest_rate: import("decimal.js").Decimal;
2781
2781
  }, {
2782
2782
  is_active: boolean;
2783
- min_tick_size: number;
2784
- min_lot_size: number;
2785
- min_interest_rate_clamp: number;
2786
- max_interest_rate_clamp: number;
2787
- min_funding_rate_clamp: number;
2788
- max_funding_rate_clamp: number;
2789
- impact_margin: number;
2790
- interest_rate: number;
2783
+ min_tick_size: string | number;
2784
+ min_lot_size: string | number;
2785
+ min_interest_rate_clamp: string | number;
2786
+ max_interest_rate_clamp: string | number;
2787
+ min_funding_rate_clamp: string | number;
2788
+ max_funding_rate_clamp: string | number;
2789
+ impact_margin: string | number;
2790
+ interest_rate: string | number;
2791
2791
  }>>;
2792
2792
  }, "strip", z.ZodTypeAny, {
2793
2793
  value: {
2794
2794
  is_active: boolean;
2795
- min_tick_size: number;
2796
- min_lot_size: number;
2797
- min_interest_rate_clamp: number;
2798
- max_interest_rate_clamp: number;
2799
- min_funding_rate_clamp: number;
2800
- max_funding_rate_clamp: number;
2801
- impact_margin: number;
2802
- interest_rate: number;
2795
+ min_tick_size: import("decimal.js").Decimal;
2796
+ min_lot_size: import("decimal.js").Decimal;
2797
+ min_interest_rate_clamp: import("decimal.js").Decimal;
2798
+ max_interest_rate_clamp: import("decimal.js").Decimal;
2799
+ min_funding_rate_clamp: import("decimal.js").Decimal;
2800
+ max_funding_rate_clamp: import("decimal.js").Decimal;
2801
+ impact_margin: import("decimal.js").Decimal;
2802
+ interest_rate: import("decimal.js").Decimal;
2803
2803
  } | null;
2804
2804
  key: number;
2805
2805
  }, {
2806
2806
  value: {
2807
2807
  is_active: boolean;
2808
- min_tick_size: number;
2809
- min_lot_size: number;
2810
- min_interest_rate_clamp: number;
2811
- max_interest_rate_clamp: number;
2812
- min_funding_rate_clamp: number;
2813
- max_funding_rate_clamp: number;
2814
- impact_margin: number;
2815
- interest_rate: number;
2808
+ min_tick_size: string | number;
2809
+ min_lot_size: string | number;
2810
+ min_interest_rate_clamp: string | number;
2811
+ max_interest_rate_clamp: string | number;
2812
+ min_funding_rate_clamp: string | number;
2813
+ max_funding_rate_clamp: string | number;
2814
+ impact_margin: string | number;
2815
+ interest_rate: string | number;
2816
2816
  } | null;
2817
2817
  key: number;
2818
2818
  }>;
2819
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
2819
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
2820
2820
  }, "strip", z.ZodTypeAny, {
2821
2821
  data: {
2822
2822
  value: {
2823
2823
  is_active: boolean;
2824
- min_tick_size: number;
2825
- min_lot_size: number;
2826
- min_interest_rate_clamp: number;
2827
- max_interest_rate_clamp: number;
2828
- min_funding_rate_clamp: number;
2829
- max_funding_rate_clamp: number;
2830
- impact_margin: number;
2831
- interest_rate: number;
2824
+ min_tick_size: import("decimal.js").Decimal;
2825
+ min_lot_size: import("decimal.js").Decimal;
2826
+ min_interest_rate_clamp: import("decimal.js").Decimal;
2827
+ max_interest_rate_clamp: import("decimal.js").Decimal;
2828
+ min_funding_rate_clamp: import("decimal.js").Decimal;
2829
+ max_funding_rate_clamp: import("decimal.js").Decimal;
2830
+ impact_margin: import("decimal.js").Decimal;
2831
+ interest_rate: import("decimal.js").Decimal;
2832
2832
  } | null;
2833
2833
  key: number;
2834
2834
  };
2835
- meta?: Map<any, unknown> | undefined;
2835
+ meta?: Map<unknown, unknown> | undefined;
2836
2836
  }, {
2837
2837
  data: {
2838
2838
  value: {
2839
2839
  is_active: boolean;
2840
- min_tick_size: number;
2841
- min_lot_size: number;
2842
- min_interest_rate_clamp: number;
2843
- max_interest_rate_clamp: number;
2844
- min_funding_rate_clamp: number;
2845
- max_funding_rate_clamp: number;
2846
- impact_margin: number;
2847
- interest_rate: number;
2840
+ min_tick_size: string | number;
2841
+ min_lot_size: string | number;
2842
+ min_interest_rate_clamp: string | number;
2843
+ max_interest_rate_clamp: string | number;
2844
+ min_funding_rate_clamp: string | number;
2845
+ max_funding_rate_clamp: string | number;
2846
+ impact_margin: string | number;
2847
+ interest_rate: string | number;
2848
2848
  } | null;
2849
2849
  key: number;
2850
2850
  };
@@ -2856,133 +2856,133 @@ export declare const ResponseSchemas: {
2856
2856
  perp_leverage_tables: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2857
2857
  tiers: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2858
2858
  max_leverage: z.ZodNumber;
2859
- mmr: z.ZodNumber;
2860
- maintenance_amount: z.ZodNumber;
2859
+ mmr: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2860
+ maintenance_amount: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2861
2861
  }, "strip", z.ZodTypeAny, {
2862
2862
  max_leverage: number;
2863
- mmr: number;
2864
- maintenance_amount: number;
2863
+ mmr: import("decimal.js").Decimal;
2864
+ maintenance_amount: import("decimal.js").Decimal;
2865
2865
  }, {
2866
2866
  max_leverage: number;
2867
- mmr: number;
2868
- maintenance_amount: number;
2869
- }>>, Map<any, {
2867
+ mmr: string | number;
2868
+ maintenance_amount: string | number;
2869
+ }>>, Map<string, {
2870
2870
  max_leverage: number;
2871
- mmr: number;
2872
- maintenance_amount: number;
2871
+ mmr: import("decimal.js").Decimal;
2872
+ maintenance_amount: import("decimal.js").Decimal;
2873
2873
  }>, Record<string, {
2874
2874
  max_leverage: number;
2875
- mmr: number;
2876
- maintenance_amount: number;
2875
+ mmr: string | number;
2876
+ maintenance_amount: string | number;
2877
2877
  }>>;
2878
2878
  }, "strip", z.ZodTypeAny, {
2879
- tiers: Map<any, {
2879
+ tiers: Map<string, {
2880
2880
  max_leverage: number;
2881
- mmr: number;
2882
- maintenance_amount: number;
2881
+ mmr: import("decimal.js").Decimal;
2882
+ maintenance_amount: import("decimal.js").Decimal;
2883
2883
  }>;
2884
2884
  }, {
2885
2885
  tiers: Record<string, {
2886
2886
  max_leverage: number;
2887
- mmr: number;
2888
- maintenance_amount: number;
2887
+ mmr: string | number;
2888
+ maintenance_amount: string | number;
2889
2889
  }>;
2890
- }>>, Map<any, {
2891
- tiers: Map<any, {
2890
+ }>>, Map<number, {
2891
+ tiers: Map<string, {
2892
2892
  max_leverage: number;
2893
- mmr: number;
2894
- maintenance_amount: number;
2893
+ mmr: import("decimal.js").Decimal;
2894
+ maintenance_amount: import("decimal.js").Decimal;
2895
2895
  }>;
2896
2896
  }>, Record<string, {
2897
2897
  tiers: Record<string, {
2898
2898
  max_leverage: number;
2899
- mmr: number;
2900
- maintenance_amount: number;
2899
+ mmr: string | number;
2900
+ maintenance_amount: string | number;
2901
2901
  }>;
2902
2902
  }>>;
2903
- liquidation_ioc_buffer: z.ZodNumber;
2904
- backstop_liquidation_threshold: z.ZodNumber;
2905
- liquidation_fee: z.ZodNumber;
2903
+ liquidation_ioc_buffer: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2904
+ backstop_liquidation_threshold: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2905
+ liquidation_fee: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, import("decimal.js").Decimal, string | number>;
2906
2906
  }, "strip", z.ZodTypeAny, {
2907
- perp_leverage_tables: Map<any, {
2908
- tiers: Map<any, {
2907
+ perp_leverage_tables: Map<number, {
2908
+ tiers: Map<string, {
2909
2909
  max_leverage: number;
2910
- mmr: number;
2911
- maintenance_amount: number;
2910
+ mmr: import("decimal.js").Decimal;
2911
+ maintenance_amount: import("decimal.js").Decimal;
2912
2912
  }>;
2913
2913
  }>;
2914
- liquidation_ioc_buffer: number;
2915
- backstop_liquidation_threshold: number;
2916
- liquidation_fee: number;
2914
+ liquidation_ioc_buffer: import("decimal.js").Decimal;
2915
+ backstop_liquidation_threshold: import("decimal.js").Decimal;
2916
+ liquidation_fee: import("decimal.js").Decimal;
2917
2917
  }, {
2918
2918
  perp_leverage_tables: Record<string, {
2919
2919
  tiers: Record<string, {
2920
2920
  max_leverage: number;
2921
- mmr: number;
2922
- maintenance_amount: number;
2921
+ mmr: string | number;
2922
+ maintenance_amount: string | number;
2923
2923
  }>;
2924
2924
  }>;
2925
- liquidation_ioc_buffer: number;
2926
- backstop_liquidation_threshold: number;
2927
- liquidation_fee: number;
2925
+ liquidation_ioc_buffer: string | number;
2926
+ backstop_liquidation_threshold: string | number;
2927
+ liquidation_fee: string | number;
2928
2928
  }>>;
2929
2929
  }, "strip", z.ZodTypeAny, {
2930
2930
  value: {
2931
- perp_leverage_tables: Map<any, {
2932
- tiers: Map<any, {
2931
+ perp_leverage_tables: Map<number, {
2932
+ tiers: Map<string, {
2933
2933
  max_leverage: number;
2934
- mmr: number;
2935
- maintenance_amount: number;
2934
+ mmr: import("decimal.js").Decimal;
2935
+ maintenance_amount: import("decimal.js").Decimal;
2936
2936
  }>;
2937
2937
  }>;
2938
- liquidation_ioc_buffer: number;
2939
- backstop_liquidation_threshold: number;
2940
- liquidation_fee: number;
2938
+ liquidation_ioc_buffer: import("decimal.js").Decimal;
2939
+ backstop_liquidation_threshold: import("decimal.js").Decimal;
2940
+ liquidation_fee: import("decimal.js").Decimal;
2941
2941
  } | null;
2942
2942
  }, {
2943
2943
  value: {
2944
2944
  perp_leverage_tables: Record<string, {
2945
2945
  tiers: Record<string, {
2946
2946
  max_leverage: number;
2947
- mmr: number;
2948
- maintenance_amount: number;
2947
+ mmr: string | number;
2948
+ maintenance_amount: string | number;
2949
2949
  }>;
2950
2950
  }>;
2951
- liquidation_ioc_buffer: number;
2952
- backstop_liquidation_threshold: number;
2953
- liquidation_fee: number;
2951
+ liquidation_ioc_buffer: string | number;
2952
+ backstop_liquidation_threshold: string | number;
2953
+ liquidation_fee: string | number;
2954
2954
  } | null;
2955
2955
  }>;
2956
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
2956
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
2957
2957
  }, "strip", z.ZodTypeAny, {
2958
2958
  data: {
2959
2959
  value: {
2960
- perp_leverage_tables: Map<any, {
2961
- tiers: Map<any, {
2960
+ perp_leverage_tables: Map<number, {
2961
+ tiers: Map<string, {
2962
2962
  max_leverage: number;
2963
- mmr: number;
2964
- maintenance_amount: number;
2963
+ mmr: import("decimal.js").Decimal;
2964
+ maintenance_amount: import("decimal.js").Decimal;
2965
2965
  }>;
2966
2966
  }>;
2967
- liquidation_ioc_buffer: number;
2968
- backstop_liquidation_threshold: number;
2969
- liquidation_fee: number;
2967
+ liquidation_ioc_buffer: import("decimal.js").Decimal;
2968
+ backstop_liquidation_threshold: import("decimal.js").Decimal;
2969
+ liquidation_fee: import("decimal.js").Decimal;
2970
2970
  } | null;
2971
2971
  };
2972
- meta?: Map<any, unknown> | undefined;
2972
+ meta?: Map<unknown, unknown> | undefined;
2973
2973
  }, {
2974
2974
  data: {
2975
2975
  value: {
2976
2976
  perp_leverage_tables: Record<string, {
2977
2977
  tiers: Record<string, {
2978
2978
  max_leverage: number;
2979
- mmr: number;
2980
- maintenance_amount: number;
2979
+ mmr: string | number;
2980
+ maintenance_amount: string | number;
2981
2981
  }>;
2982
2982
  }>;
2983
- liquidation_ioc_buffer: number;
2984
- backstop_liquidation_threshold: number;
2985
- liquidation_fee: number;
2983
+ liquidation_ioc_buffer: string | number;
2984
+ backstop_liquidation_threshold: string | number;
2985
+ liquidation_fee: string | number;
2986
2986
  } | null;
2987
2987
  };
2988
2988
  meta?: Record<string, unknown> | undefined;
@@ -2995,12 +2995,12 @@ export declare const ResponseSchemas: {
2995
2995
  }, {
2996
2996
  accounts: string[];
2997
2997
  }>;
2998
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
2998
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
2999
2999
  }, "strip", z.ZodTypeAny, {
3000
3000
  data: {
3001
3001
  accounts: string[];
3002
3002
  };
3003
- meta?: Map<any, unknown> | undefined;
3003
+ meta?: Map<unknown, unknown> | undefined;
3004
3004
  }, {
3005
3005
  data: {
3006
3006
  accounts: string[];
@@ -3009,18 +3009,18 @@ export declare const ResponseSchemas: {
3009
3009
  }>;
3010
3010
  readonly Assets: z.ZodObject<{
3011
3011
  data: z.ZodObject<{
3012
- assets: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Map<any, string>, Record<string, string>>;
3012
+ assets: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Map<number, string>, Record<string, string>>;
3013
3013
  }, "strip", z.ZodTypeAny, {
3014
- assets: Map<any, string>;
3014
+ assets: Map<number, string>;
3015
3015
  }, {
3016
3016
  assets: Record<string, string>;
3017
3017
  }>;
3018
- meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<any, unknown>, Record<string, unknown>>>;
3018
+ meta: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodUnknown>, Map<unknown, unknown>, Record<string, unknown>>>;
3019
3019
  }, "strip", z.ZodTypeAny, {
3020
3020
  data: {
3021
- assets: Map<any, string>;
3021
+ assets: Map<number, string>;
3022
3022
  };
3023
- meta?: Map<any, unknown> | undefined;
3023
+ meta?: Map<unknown, unknown> | undefined;
3024
3024
  }, {
3025
3025
  data: {
3026
3026
  assets: Record<string, string>;