@bulletxyz/bullet-sdk 0.16.0-rc.0 → 0.16.1-rc.0

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 (13) hide show
  1. package/dist/browser/index.js +2510 -230
  2. package/dist/browser/index.js.map +4 -4
  3. package/dist/node/index.js +2510 -230
  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/types.d.ts +4 -3
  8. package/dist/types/utils.d.ts +1 -0
  9. package/dist/types/zod-types/index.d.ts +14 -3
  10. package/dist/types/zod-types/rest.d.ts +1557 -1505
  11. package/dist/types/zod-types/wasm.d.ts +6 -6
  12. package/dist/types/zod-types/ws.d.ts +16 -16
  13. 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,891 +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
- initial_liability_weight: number;
488
- maintenance_liability_weight: number;
489
- asset_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
- initial_liability_weight: number;
492
- maintenance_liability_weight: number;
493
- asset_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
- initial_liability_weight: number;
500
- maintenance_liability_weight: number;
501
- asset_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
- initial_liability_weight: number;
508
- maintenance_liability_weight: number;
509
- asset_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
- initial_liability_weight: number;
520
- maintenance_liability_weight: number;
521
- asset_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
- initial_liability_weight: number;
532
- maintenance_liability_weight: number;
533
- asset_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
- initial_liability_weight: number;
548
- maintenance_liability_weight: number;
549
- asset_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
- initial_liability_weight: number;
552
- maintenance_liability_weight: number;
553
- asset_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
- initial_liability_weight: number;
560
- maintenance_liability_weight: number;
561
- asset_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
- initial_liability_weight: number;
568
- maintenance_liability_weight: number;
569
- asset_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
- initial_liability_weight: number;
576
- maintenance_liability_weight: number;
577
- asset_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
- initial_liability_weight: number;
584
- maintenance_liability_weight: number;
585
- asset_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
- funding_payments_on_side: z.ZodNumber;
616
- funding_payments_on_position: z.ZodNumber;
617
- last_accum_funding_applied_per_lot: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
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
- funding_payments_on_side: number;
624
- funding_payments_on_position: number;
625
- last_accum_funding_applied_per_lot: [number, 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
- funding_payments_on_side: number;
632
- funding_payments_on_position: number;
633
- last_accum_funding_applied_per_lot: [number, 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
- funding_payments_on_side: number;
687
- funding_payments_on_position: number;
688
- last_accum_funding_applied_per_lot: [number, 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
- funding_payments_on_side: number;
718
- funding_payments_on_position: number;
719
- last_accum_funding_applied_per_lot: [number, 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
- funding_payments_on_side: number;
749
- funding_payments_on_position: number;
750
- last_accum_funding_applied_per_lot: [number, 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
- funding_payments_on_side: number;
780
- funding_payments_on_position: number;
781
- last_accum_funding_applied_per_lot: [number, 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
- initial_liability_weight: number;
803
- maintenance_liability_weight: number;
804
- asset_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
- initial_liability_weight: number;
815
- maintenance_liability_weight: number;
816
- asset_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
- funding_payments_on_side: number;
835
- funding_payments_on_position: number;
836
- last_accum_funding_applied_per_lot: [number, 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
- initial_liability_weight: number;
858
- maintenance_liability_weight: number;
859
- asset_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
- initial_liability_weight: number;
870
- maintenance_liability_weight: number;
871
- asset_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
- funding_payments_on_side: number;
890
- funding_payments_on_position: number;
891
- last_accum_funding_applied_per_lot: [number, 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
- weight: z.ZodNumber;
991
- initial_liability_weight: z.ZodNumber;
992
- maintenance_liability_weight: z.ZodNumber;
993
- deposit_limit: z.ZodNumber;
994
- borrow_limit: z.ZodNumber;
995
- liquidation_reward_ratio: z.ZodNumber;
996
- liability_liquidation_limit_ratio: z.ZodNumber;
990
+ weights: z.ZodObject<{
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
+ }, "strip", z.ZodTypeAny, {
995
+ asset_weight: import("decimal.js").Decimal;
996
+ initial_liability_weight: import("decimal.js").Decimal;
997
+ maintenance_liability_weight: import("decimal.js").Decimal;
998
+ }, {
999
+ asset_weight: string | number;
1000
+ initial_liability_weight: string | number;
1001
+ maintenance_liability_weight: string | number;
1002
+ }>;
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>;
997
1007
  }, "strip", z.ZodTypeAny, {
998
- weight: number;
999
- initial_liability_weight: number;
1000
- maintenance_liability_weight: number;
1001
- deposit_limit: number;
1002
- borrow_limit: number;
1003
- liquidation_reward_ratio: number;
1004
- liability_liquidation_limit_ratio: number;
1008
+ weights: {
1009
+ asset_weight: import("decimal.js").Decimal;
1010
+ initial_liability_weight: import("decimal.js").Decimal;
1011
+ maintenance_liability_weight: import("decimal.js").Decimal;
1012
+ };
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;
1005
1017
  }, {
1006
- weight: number;
1007
- initial_liability_weight: number;
1008
- maintenance_liability_weight: number;
1009
- deposit_limit: number;
1010
- borrow_limit: number;
1011
- liquidation_reward_ratio: number;
1012
- liability_liquidation_limit_ratio: number;
1018
+ weights: {
1019
+ asset_weight: string | number;
1020
+ initial_liability_weight: string | number;
1021
+ maintenance_liability_weight: string | number;
1022
+ };
1023
+ deposit_limit: string | number;
1024
+ borrow_limit: string | number;
1025
+ liquidation_reward_ratio: string | number;
1026
+ liability_liquidation_limit_ratio: string | number;
1013
1027
  }>;
1014
1028
  rate_params: z.ZodObject<{
1015
- optimal_utilisation_rate: z.ZodNumber;
1016
- min_borrow_rate: z.ZodNumber;
1017
- optimal_borrow_rate: z.ZodNumber;
1018
- 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>;
1019
1033
  }, "strip", z.ZodTypeAny, {
1020
- optimal_utilisation_rate: number;
1021
- min_borrow_rate: number;
1022
- optimal_borrow_rate: number;
1023
- 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;
1024
1038
  }, {
1025
- optimal_utilisation_rate: number;
1026
- min_borrow_rate: number;
1027
- optimal_borrow_rate: number;
1028
- 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;
1029
1043
  }>;
1030
- available_amount: z.ZodNumber;
1031
- borrowed_amount: z.ZodNumber;
1032
- cumulative_deposit_rate: z.ZodNumber;
1033
- cumulative_borrow_rate: z.ZodNumber;
1034
- 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>;
1035
1049
  }, "strip", z.ZodTypeAny, {
1036
1050
  is_active: boolean;
1037
- last_update_timestamp: number;
1051
+ last_update_timestamp: bigint;
1038
1052
  decimals: number;
1039
1053
  risk_params: {
1040
- weight: number;
1041
- initial_liability_weight: number;
1042
- maintenance_liability_weight: number;
1043
- deposit_limit: number;
1044
- borrow_limit: number;
1045
- liquidation_reward_ratio: number;
1046
- liability_liquidation_limit_ratio: number;
1054
+ weights: {
1055
+ asset_weight: import("decimal.js").Decimal;
1056
+ initial_liability_weight: import("decimal.js").Decimal;
1057
+ maintenance_liability_weight: import("decimal.js").Decimal;
1058
+ };
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;
1047
1063
  };
1048
1064
  rate_params: {
1049
- optimal_utilisation_rate: number;
1050
- min_borrow_rate: number;
1051
- optimal_borrow_rate: number;
1052
- 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;
1053
1069
  };
1054
- available_amount: number;
1055
- borrowed_amount: number;
1056
- cumulative_deposit_rate: number;
1057
- cumulative_borrow_rate: number;
1058
- 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;
1059
1075
  }, {
1060
1076
  is_active: boolean;
1061
- last_update_timestamp: number;
1077
+ last_update_timestamp: bigint;
1062
1078
  decimals: number;
1063
1079
  risk_params: {
1064
- weight: number;
1065
- initial_liability_weight: number;
1066
- maintenance_liability_weight: number;
1067
- deposit_limit: number;
1068
- borrow_limit: number;
1069
- liquidation_reward_ratio: number;
1070
- liability_liquidation_limit_ratio: number;
1080
+ weights: {
1081
+ asset_weight: string | number;
1082
+ initial_liability_weight: string | number;
1083
+ maintenance_liability_weight: string | number;
1084
+ };
1085
+ deposit_limit: string | number;
1086
+ borrow_limit: string | number;
1087
+ liquidation_reward_ratio: string | number;
1088
+ liability_liquidation_limit_ratio: string | number;
1071
1089
  };
1072
1090
  rate_params: {
1073
- optimal_utilisation_rate: number;
1074
- min_borrow_rate: number;
1075
- optimal_borrow_rate: number;
1076
- 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;
1077
1095
  };
1078
- available_amount: number;
1079
- borrowed_amount: number;
1080
- cumulative_deposit_rate: number;
1081
- cumulative_borrow_rate: number;
1082
- 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;
1083
1101
  }>;
1084
- utilisation_rate: z.ZodNumber;
1085
- current_deposit_rate: z.ZodNumber;
1086
- 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>;
1087
1105
  }, "strip", z.ZodTypeAny, {
1088
1106
  market: {
1089
1107
  is_active: boolean;
1090
- last_update_timestamp: number;
1108
+ last_update_timestamp: bigint;
1091
1109
  decimals: number;
1092
1110
  risk_params: {
1093
- weight: number;
1094
- initial_liability_weight: number;
1095
- maintenance_liability_weight: number;
1096
- deposit_limit: number;
1097
- borrow_limit: number;
1098
- liquidation_reward_ratio: number;
1099
- liability_liquidation_limit_ratio: number;
1111
+ weights: {
1112
+ asset_weight: import("decimal.js").Decimal;
1113
+ initial_liability_weight: import("decimal.js").Decimal;
1114
+ maintenance_liability_weight: import("decimal.js").Decimal;
1115
+ };
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;
1100
1120
  };
1101
1121
  rate_params: {
1102
- optimal_utilisation_rate: number;
1103
- min_borrow_rate: number;
1104
- optimal_borrow_rate: number;
1105
- 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;
1106
1126
  };
1107
- available_amount: number;
1108
- borrowed_amount: number;
1109
- cumulative_deposit_rate: number;
1110
- cumulative_borrow_rate: number;
1111
- 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;
1112
1132
  };
1113
- utilisation_rate: number;
1114
- current_deposit_rate: number;
1115
- 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;
1116
1136
  }, {
1117
1137
  market: {
1118
1138
  is_active: boolean;
1119
- last_update_timestamp: number;
1139
+ last_update_timestamp: bigint;
1120
1140
  decimals: number;
1121
1141
  risk_params: {
1122
- weight: number;
1123
- initial_liability_weight: number;
1124
- maintenance_liability_weight: number;
1125
- deposit_limit: number;
1126
- borrow_limit: number;
1127
- liquidation_reward_ratio: number;
1128
- liability_liquidation_limit_ratio: number;
1142
+ weights: {
1143
+ asset_weight: string | number;
1144
+ initial_liability_weight: string | number;
1145
+ maintenance_liability_weight: string | number;
1146
+ };
1147
+ deposit_limit: string | number;
1148
+ borrow_limit: string | number;
1149
+ liquidation_reward_ratio: string | number;
1150
+ liability_liquidation_limit_ratio: string | number;
1129
1151
  };
1130
1152
  rate_params: {
1131
- optimal_utilisation_rate: number;
1132
- min_borrow_rate: number;
1133
- optimal_borrow_rate: number;
1134
- 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;
1135
1157
  };
1136
- available_amount: number;
1137
- borrowed_amount: number;
1138
- cumulative_deposit_rate: number;
1139
- cumulative_borrow_rate: number;
1140
- 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;
1141
1163
  };
1142
- utilisation_rate: number;
1143
- current_deposit_rate: number;
1144
- current_borrow_rate: number;
1164
+ utilisation_rate: string | number;
1165
+ current_deposit_rate: string | number;
1166
+ current_borrow_rate: string | number;
1145
1167
  }>;
1146
1168
  readonly PerpMarket: z.ZodObject<{
1147
1169
  is_active: z.ZodBoolean;
1148
- min_tick_size: z.ZodNumber;
1149
- min_lot_size: z.ZodNumber;
1150
- min_interest_rate_clamp: z.ZodNumber;
1151
- max_interest_rate_clamp: z.ZodNumber;
1152
- min_funding_rate_clamp: z.ZodNumber;
1153
- max_funding_rate_clamp: z.ZodNumber;
1154
- impact_margin: z.ZodNumber;
1155
- 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>;
1156
1178
  }, "strip", z.ZodTypeAny, {
1157
1179
  is_active: boolean;
1158
- min_tick_size: number;
1159
- min_lot_size: number;
1160
- min_interest_rate_clamp: number;
1161
- max_interest_rate_clamp: number;
1162
- min_funding_rate_clamp: number;
1163
- max_funding_rate_clamp: number;
1164
- impact_margin: number;
1165
- 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;
1166
1188
  }, {
1167
1189
  is_active: boolean;
1168
- min_tick_size: number;
1169
- min_lot_size: number;
1170
- min_interest_rate_clamp: number;
1171
- max_interest_rate_clamp: number;
1172
- min_funding_rate_clamp: number;
1173
- max_funding_rate_clamp: number;
1174
- impact_margin: number;
1175
- 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;
1176
1198
  }>;
1177
1199
  readonly MarginConfig: z.ZodObject<{
1178
1200
  perp_leverage_tables: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
1179
1201
  tiers: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
1180
1202
  max_leverage: z.ZodNumber;
1181
- mmr: z.ZodNumber;
1182
- 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>;
1183
1205
  }, "strip", z.ZodTypeAny, {
1184
1206
  max_leverage: number;
1185
- mmr: number;
1186
- maintenance_amount: number;
1207
+ mmr: import("decimal.js").Decimal;
1208
+ maintenance_amount: import("decimal.js").Decimal;
1187
1209
  }, {
1188
1210
  max_leverage: number;
1189
- mmr: number;
1190
- maintenance_amount: number;
1191
- }>>, Map<any, {
1211
+ mmr: string | number;
1212
+ maintenance_amount: string | number;
1213
+ }>>, Map<string, {
1192
1214
  max_leverage: number;
1193
- mmr: number;
1194
- maintenance_amount: number;
1215
+ mmr: import("decimal.js").Decimal;
1216
+ maintenance_amount: import("decimal.js").Decimal;
1195
1217
  }>, Record<string, {
1196
1218
  max_leverage: number;
1197
- mmr: number;
1198
- maintenance_amount: number;
1219
+ mmr: string | number;
1220
+ maintenance_amount: string | number;
1199
1221
  }>>;
1200
1222
  }, "strip", z.ZodTypeAny, {
1201
- tiers: Map<any, {
1223
+ tiers: Map<string, {
1202
1224
  max_leverage: number;
1203
- mmr: number;
1204
- maintenance_amount: number;
1225
+ mmr: import("decimal.js").Decimal;
1226
+ maintenance_amount: import("decimal.js").Decimal;
1205
1227
  }>;
1206
1228
  }, {
1207
1229
  tiers: Record<string, {
1208
1230
  max_leverage: number;
1209
- mmr: number;
1210
- maintenance_amount: number;
1231
+ mmr: string | number;
1232
+ maintenance_amount: string | number;
1211
1233
  }>;
1212
- }>>, Map<any, {
1213
- tiers: Map<any, {
1234
+ }>>, Map<number, {
1235
+ tiers: Map<string, {
1214
1236
  max_leverage: number;
1215
- mmr: number;
1216
- maintenance_amount: number;
1237
+ mmr: import("decimal.js").Decimal;
1238
+ maintenance_amount: import("decimal.js").Decimal;
1217
1239
  }>;
1218
1240
  }>, Record<string, {
1219
1241
  tiers: Record<string, {
1220
1242
  max_leverage: number;
1221
- mmr: number;
1222
- maintenance_amount: number;
1243
+ mmr: string | number;
1244
+ maintenance_amount: string | number;
1223
1245
  }>;
1224
1246
  }>>;
1225
- liquidation_ioc_buffer: z.ZodNumber;
1226
- backstop_liquidation_threshold: z.ZodNumber;
1227
- 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>;
1228
1250
  }, "strip", z.ZodTypeAny, {
1229
- perp_leverage_tables: Map<any, {
1230
- tiers: Map<any, {
1251
+ perp_leverage_tables: Map<number, {
1252
+ tiers: Map<string, {
1231
1253
  max_leverage: number;
1232
- mmr: number;
1233
- maintenance_amount: number;
1254
+ mmr: import("decimal.js").Decimal;
1255
+ maintenance_amount: import("decimal.js").Decimal;
1234
1256
  }>;
1235
1257
  }>;
1236
- liquidation_ioc_buffer: number;
1237
- backstop_liquidation_threshold: number;
1238
- 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;
1239
1261
  }, {
1240
1262
  perp_leverage_tables: Record<string, {
1241
1263
  tiers: Record<string, {
1242
1264
  max_leverage: number;
1243
- mmr: number;
1244
- maintenance_amount: number;
1265
+ mmr: string | number;
1266
+ maintenance_amount: string | number;
1245
1267
  }>;
1246
1268
  }>;
1247
- liquidation_ioc_buffer: number;
1248
- backstop_liquidation_threshold: number;
1249
- liquidation_fee: number;
1269
+ liquidation_ioc_buffer: string | number;
1270
+ backstop_liquidation_threshold: string | number;
1271
+ liquidation_fee: string | number;
1250
1272
  }>;
1251
1273
  readonly Assets: z.ZodObject<{
1252
- 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>>;
1253
1275
  }, "strip", z.ZodTypeAny, {
1254
- assets: Map<any, string>;
1276
+ assets: Map<number, string>;
1255
1277
  }, {
1256
1278
  assets: Record<string, string>;
1257
1279
  }>;
@@ -1265,12 +1287,12 @@ export declare const ResponseSchemas: {
1265
1287
  }, {
1266
1288
  value: number | null;
1267
1289
  }>;
1268
- 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>>>;
1269
1291
  }, "strip", z.ZodTypeAny, {
1270
1292
  data: {
1271
1293
  value: number | null;
1272
1294
  };
1273
- meta?: Map<any, unknown> | undefined;
1295
+ meta?: Map<unknown, unknown> | undefined;
1274
1296
  }, {
1275
1297
  data: {
1276
1298
  value: number | null;
@@ -1279,103 +1301,103 @@ export declare const ResponseSchemas: {
1279
1301
  }>;
1280
1302
  readonly Order: z.ZodObject<{
1281
1303
  data: z.ZodObject<{
1282
- key: z.ZodNumber;
1304
+ key: z.ZodBigInt;
1283
1305
  value: z.ZodNullable<z.ZodObject<{
1284
1306
  side: z.ZodEnum<["Bid", "Ask"]>;
1285
1307
  asset_id: z.ZodNumber;
1286
- order_id: z.ZodNumber;
1287
- price: z.ZodNumber;
1288
- 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>;
1289
1311
  reduce_only: z.ZodBoolean;
1290
- filled_size: z.ZodNumber;
1291
- 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>;
1292
1314
  owner: z.ZodString;
1293
- tpsl_order_ids: z.ZodArray<z.ZodNumber, "many">;
1315
+ tpsl_order_ids: z.ZodArray<z.ZodBigInt, "many">;
1294
1316
  }, "strip", z.ZodTypeAny, {
1295
- size: number;
1296
- price: number;
1317
+ size: import("decimal.js").Decimal;
1318
+ price: import("decimal.js").Decimal;
1297
1319
  side: "Bid" | "Ask";
1298
- order_id: number;
1320
+ order_id: bigint;
1299
1321
  reduce_only: boolean;
1300
1322
  asset_id: number;
1301
- filled_size: number;
1302
- average_filled_price: number;
1323
+ filled_size: import("decimal.js").Decimal;
1324
+ average_filled_price: import("decimal.js").Decimal;
1303
1325
  owner: string;
1304
- tpsl_order_ids: number[];
1326
+ tpsl_order_ids: bigint[];
1305
1327
  }, {
1306
- size: number;
1307
- price: number;
1328
+ size: string | number;
1329
+ price: string | number;
1308
1330
  side: "Bid" | "Ask";
1309
- order_id: number;
1331
+ order_id: bigint;
1310
1332
  reduce_only: boolean;
1311
1333
  asset_id: number;
1312
- filled_size: number;
1313
- average_filled_price: number;
1334
+ filled_size: string | number;
1335
+ average_filled_price: string | number;
1314
1336
  owner: string;
1315
- tpsl_order_ids: number[];
1337
+ tpsl_order_ids: bigint[];
1316
1338
  }>>;
1317
1339
  }, "strip", z.ZodTypeAny, {
1318
1340
  value: {
1319
- size: number;
1320
- price: number;
1341
+ size: import("decimal.js").Decimal;
1342
+ price: import("decimal.js").Decimal;
1321
1343
  side: "Bid" | "Ask";
1322
- order_id: number;
1344
+ order_id: bigint;
1323
1345
  reduce_only: boolean;
1324
1346
  asset_id: number;
1325
- filled_size: number;
1326
- average_filled_price: number;
1347
+ filled_size: import("decimal.js").Decimal;
1348
+ average_filled_price: import("decimal.js").Decimal;
1327
1349
  owner: string;
1328
- tpsl_order_ids: number[];
1350
+ tpsl_order_ids: bigint[];
1329
1351
  } | null;
1330
- key: number;
1352
+ key: bigint;
1331
1353
  }, {
1332
1354
  value: {
1333
- size: number;
1334
- price: number;
1355
+ size: string | number;
1356
+ price: string | number;
1335
1357
  side: "Bid" | "Ask";
1336
- order_id: number;
1358
+ order_id: bigint;
1337
1359
  reduce_only: boolean;
1338
1360
  asset_id: number;
1339
- filled_size: number;
1340
- average_filled_price: number;
1361
+ filled_size: string | number;
1362
+ average_filled_price: string | number;
1341
1363
  owner: string;
1342
- tpsl_order_ids: number[];
1364
+ tpsl_order_ids: bigint[];
1343
1365
  } | null;
1344
- key: number;
1366
+ key: bigint;
1345
1367
  }>;
1346
- 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>>>;
1347
1369
  }, "strip", z.ZodTypeAny, {
1348
1370
  data: {
1349
1371
  value: {
1350
- size: number;
1351
- price: number;
1372
+ size: import("decimal.js").Decimal;
1373
+ price: import("decimal.js").Decimal;
1352
1374
  side: "Bid" | "Ask";
1353
- order_id: number;
1375
+ order_id: bigint;
1354
1376
  reduce_only: boolean;
1355
1377
  asset_id: number;
1356
- filled_size: number;
1357
- average_filled_price: number;
1378
+ filled_size: import("decimal.js").Decimal;
1379
+ average_filled_price: import("decimal.js").Decimal;
1358
1380
  owner: string;
1359
- tpsl_order_ids: number[];
1381
+ tpsl_order_ids: bigint[];
1360
1382
  } | null;
1361
- key: number;
1383
+ key: bigint;
1362
1384
  };
1363
- meta?: Map<any, unknown> | undefined;
1385
+ meta?: Map<unknown, unknown> | undefined;
1364
1386
  }, {
1365
1387
  data: {
1366
1388
  value: {
1367
- size: number;
1368
- price: number;
1389
+ size: string | number;
1390
+ price: string | number;
1369
1391
  side: "Bid" | "Ask";
1370
- order_id: number;
1392
+ order_id: bigint;
1371
1393
  reduce_only: boolean;
1372
1394
  asset_id: number;
1373
- filled_size: number;
1374
- average_filled_price: number;
1395
+ filled_size: string | number;
1396
+ average_filled_price: string | number;
1375
1397
  owner: string;
1376
- tpsl_order_ids: number[];
1398
+ tpsl_order_ids: bigint[];
1377
1399
  } | null;
1378
- key: number;
1400
+ key: bigint;
1379
1401
  };
1380
1402
  meta?: Record<string, unknown> | undefined;
1381
1403
  }>;
@@ -1385,429 +1407,429 @@ export declare const ResponseSchemas: {
1385
1407
  usdc_ledger: z.ZodObject<{
1386
1408
  ledger: z.ZodObject<{
1387
1409
  weights: z.ZodObject<{
1388
- asset_weight: z.ZodNumber;
1389
- initial_liability_weight: z.ZodNumber;
1390
- 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>;
1391
1413
  }, "strip", z.ZodTypeAny, {
1392
- initial_liability_weight: number;
1393
- maintenance_liability_weight: number;
1394
- asset_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;
1395
1417
  }, {
1396
- initial_liability_weight: number;
1397
- maintenance_liability_weight: number;
1398
- asset_weight: number;
1418
+ asset_weight: string | number;
1419
+ initial_liability_weight: string | number;
1420
+ maintenance_liability_weight: string | number;
1399
1421
  }>;
1400
- asset: z.ZodNumber;
1401
- 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>;
1402
1424
  }, "strip", z.ZodTypeAny, {
1403
1425
  weights: {
1404
- initial_liability_weight: number;
1405
- maintenance_liability_weight: number;
1406
- asset_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;
1407
1429
  };
1408
- asset: number;
1409
- liability: number;
1430
+ asset: import("decimal.js").Decimal;
1431
+ liability: import("decimal.js").Decimal;
1410
1432
  }, {
1411
1433
  weights: {
1412
- initial_liability_weight: number;
1413
- maintenance_liability_weight: number;
1414
- asset_weight: number;
1434
+ asset_weight: string | number;
1435
+ initial_liability_weight: string | number;
1436
+ maintenance_liability_weight: string | number;
1415
1437
  };
1416
- asset: number;
1417
- liability: number;
1438
+ asset: string | number;
1439
+ liability: string | number;
1418
1440
  }>;
1419
- unrealized_loss_borrow: z.ZodNumber;
1420
- 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>;
1421
1443
  }, "strip", z.ZodTypeAny, {
1422
1444
  ledger: {
1423
1445
  weights: {
1424
- initial_liability_weight: number;
1425
- maintenance_liability_weight: number;
1426
- asset_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;
1427
1449
  };
1428
- asset: number;
1429
- liability: number;
1450
+ asset: import("decimal.js").Decimal;
1451
+ liability: import("decimal.js").Decimal;
1430
1452
  };
1431
- unrealized_loss_borrow: number;
1432
- unsettled_perp_profit: number;
1453
+ unrealized_loss_borrow: import("decimal.js").Decimal;
1454
+ unsettled_perp_profit: import("decimal.js").Decimal;
1433
1455
  }, {
1434
1456
  ledger: {
1435
1457
  weights: {
1436
- initial_liability_weight: number;
1437
- maintenance_liability_weight: number;
1438
- asset_weight: number;
1458
+ asset_weight: string | number;
1459
+ initial_liability_weight: string | number;
1460
+ maintenance_liability_weight: string | number;
1439
1461
  };
1440
- asset: number;
1441
- liability: number;
1462
+ asset: string | number;
1463
+ liability: string | number;
1442
1464
  };
1443
- unrealized_loss_borrow: number;
1444
- unsettled_perp_profit: number;
1465
+ unrealized_loss_borrow: string | number;
1466
+ unsettled_perp_profit: string | number;
1445
1467
  }>;
1446
1468
  spot_ledgers: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
1447
1469
  weights: z.ZodObject<{
1448
- asset_weight: z.ZodNumber;
1449
- initial_liability_weight: z.ZodNumber;
1450
- 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>;
1451
1473
  }, "strip", z.ZodTypeAny, {
1452
- initial_liability_weight: number;
1453
- maintenance_liability_weight: number;
1454
- asset_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;
1455
1477
  }, {
1456
- initial_liability_weight: number;
1457
- maintenance_liability_weight: number;
1458
- asset_weight: number;
1478
+ asset_weight: string | number;
1479
+ initial_liability_weight: string | number;
1480
+ maintenance_liability_weight: string | number;
1459
1481
  }>;
1460
- asset: z.ZodNumber;
1461
- 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>;
1462
1484
  }, "strip", z.ZodTypeAny, {
1463
1485
  weights: {
1464
- initial_liability_weight: number;
1465
- maintenance_liability_weight: number;
1466
- asset_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;
1467
1489
  };
1468
- asset: number;
1469
- liability: number;
1490
+ asset: import("decimal.js").Decimal;
1491
+ liability: import("decimal.js").Decimal;
1470
1492
  }, {
1471
1493
  weights: {
1472
- initial_liability_weight: number;
1473
- maintenance_liability_weight: number;
1474
- asset_weight: number;
1494
+ asset_weight: string | number;
1495
+ initial_liability_weight: string | number;
1496
+ maintenance_liability_weight: string | number;
1475
1497
  };
1476
- asset: number;
1477
- liability: number;
1478
- }>>, Map<any, {
1498
+ asset: string | number;
1499
+ liability: string | number;
1500
+ }>>, Map<number, {
1479
1501
  weights: {
1480
- initial_liability_weight: number;
1481
- maintenance_liability_weight: number;
1482
- asset_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;
1483
1505
  };
1484
- asset: number;
1485
- liability: number;
1506
+ asset: import("decimal.js").Decimal;
1507
+ liability: import("decimal.js").Decimal;
1486
1508
  }>, Record<string, {
1487
1509
  weights: {
1488
- initial_liability_weight: number;
1489
- maintenance_liability_weight: number;
1490
- asset_weight: number;
1510
+ asset_weight: string | number;
1511
+ initial_liability_weight: string | number;
1512
+ maintenance_liability_weight: string | number;
1491
1513
  };
1492
- asset: number;
1493
- liability: number;
1514
+ asset: string | number;
1515
+ liability: string | number;
1494
1516
  }>>;
1495
1517
  perp_ledgers: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
1496
1518
  orders: z.ZodArray<z.ZodObject<{
1497
- size: z.ZodNumber;
1498
- 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>;
1499
1521
  side: z.ZodEnum<["Bid", "Ask"]>;
1500
- order_id: z.ZodNumber;
1522
+ order_id: z.ZodBigInt;
1501
1523
  reduce_only: z.ZodBoolean;
1502
1524
  }, "strip", z.ZodTypeAny, {
1503
- size: number;
1504
- price: number;
1525
+ size: import("decimal.js").Decimal;
1526
+ price: import("decimal.js").Decimal;
1505
1527
  side: "Bid" | "Ask";
1506
- order_id: number;
1528
+ order_id: bigint;
1507
1529
  reduce_only: boolean;
1508
1530
  }, {
1509
- size: number;
1510
- price: number;
1531
+ size: string | number;
1532
+ price: string | number;
1511
1533
  side: "Bid" | "Ask";
1512
- order_id: number;
1534
+ order_id: bigint;
1513
1535
  reduce_only: boolean;
1514
1536
  }>, "many">;
1515
1537
  position: z.ZodObject<{
1516
- size: z.ZodNumber;
1517
- cost_of_trades: z.ZodNumber;
1518
- realized_pnl: z.ZodNumber;
1519
- cached_mark_price: z.ZodNumber;
1520
- funding_payments_on_side: z.ZodNumber;
1521
- funding_payments_on_position: z.ZodNumber;
1522
- last_accum_funding_applied_per_lot: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
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>;
1523
1545
  }, "strip", z.ZodTypeAny, {
1524
- size: number;
1525
- cost_of_trades: number;
1526
- realized_pnl: number;
1527
- cached_mark_price: number;
1528
- funding_payments_on_side: number;
1529
- funding_payments_on_position: number;
1530
- last_accum_funding_applied_per_lot: [number, 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;
1531
1553
  }, {
1532
- size: number;
1533
- cost_of_trades: number;
1534
- realized_pnl: number;
1535
- cached_mark_price: number;
1536
- funding_payments_on_side: number;
1537
- funding_payments_on_position: number;
1538
- last_accum_funding_applied_per_lot: [number, 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;
1539
1561
  }>;
1540
1562
  user_selected_max_leverage: z.ZodNumber;
1541
1563
  tpsls: z.ZodArray<z.ZodObject<{
1542
1564
  side: z.ZodEnum<["Bid", "Ask"]>;
1543
- tpsl_order_id: z.ZodNumber;
1544
- order_price: z.ZodNumber;
1545
- 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>;
1546
1568
  trigger_direction: z.ZodEnum<["GreaterThanOrEqual", "LessThanOrEqual"]>;
1547
1569
  tpsl_price_condition: z.ZodEnum<["Mark", "Oracle", "LastTrade"]>;
1548
- active_size: z.ZodNumber;
1549
- 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>;
1550
1572
  order_type: z.ZodEnum<["Limit", "PostOnly", "FillOrKill", "ImmediateOrCancel", "PostOnlySlide", "PostOnlyFront"]>;
1551
- parent_order_id: z.ZodOptional<z.ZodNumber>;
1552
- 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">;
1553
1575
  }, "strip", z.ZodTypeAny, {
1554
1576
  side: "Bid" | "Ask";
1555
- tpsl_order_id: number;
1556
- order_price: number;
1557
- trigger_price: number;
1577
+ tpsl_order_id: bigint;
1578
+ order_price: import("decimal.js").Decimal;
1579
+ trigger_price: import("decimal.js").Decimal;
1558
1580
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1559
1581
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1560
- active_size: number;
1561
- full_size: number;
1582
+ active_size: import("decimal.js").Decimal;
1583
+ full_size: import("decimal.js").Decimal;
1562
1584
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1563
- linked_tpsl_order_ids: number[];
1564
- parent_order_id?: number | undefined;
1585
+ linked_tpsl_order_ids: bigint[];
1586
+ parent_order_id?: bigint | undefined;
1565
1587
  }, {
1566
1588
  side: "Bid" | "Ask";
1567
- tpsl_order_id: number;
1568
- order_price: number;
1569
- trigger_price: number;
1589
+ tpsl_order_id: bigint;
1590
+ order_price: string | number;
1591
+ trigger_price: string | number;
1570
1592
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1571
1593
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1572
- active_size: number;
1573
- full_size: number;
1594
+ active_size: string | number;
1595
+ full_size: string | number;
1574
1596
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1575
- linked_tpsl_order_ids: number[];
1576
- parent_order_id?: number | undefined;
1597
+ linked_tpsl_order_ids: bigint[];
1598
+ parent_order_id?: bigint | undefined;
1577
1599
  }>, "many">;
1578
1600
  }, "strip", z.ZodTypeAny, {
1579
1601
  orders: {
1580
- size: number;
1581
- price: number;
1602
+ size: import("decimal.js").Decimal;
1603
+ price: import("decimal.js").Decimal;
1582
1604
  side: "Bid" | "Ask";
1583
- order_id: number;
1605
+ order_id: bigint;
1584
1606
  reduce_only: boolean;
1585
1607
  }[];
1586
1608
  position: {
1587
- size: number;
1588
- cost_of_trades: number;
1589
- realized_pnl: number;
1590
- cached_mark_price: number;
1591
- funding_payments_on_side: number;
1592
- funding_payments_on_position: number;
1593
- last_accum_funding_applied_per_lot: [number, 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;
1594
1616
  };
1595
1617
  user_selected_max_leverage: number;
1596
1618
  tpsls: {
1597
1619
  side: "Bid" | "Ask";
1598
- tpsl_order_id: number;
1599
- order_price: number;
1600
- trigger_price: number;
1620
+ tpsl_order_id: bigint;
1621
+ order_price: import("decimal.js").Decimal;
1622
+ trigger_price: import("decimal.js").Decimal;
1601
1623
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1602
1624
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1603
- active_size: number;
1604
- full_size: number;
1625
+ active_size: import("decimal.js").Decimal;
1626
+ full_size: import("decimal.js").Decimal;
1605
1627
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1606
- linked_tpsl_order_ids: number[];
1607
- parent_order_id?: number | undefined;
1628
+ linked_tpsl_order_ids: bigint[];
1629
+ parent_order_id?: bigint | undefined;
1608
1630
  }[];
1609
1631
  }, {
1610
1632
  orders: {
1611
- size: number;
1612
- price: number;
1633
+ size: string | number;
1634
+ price: string | number;
1613
1635
  side: "Bid" | "Ask";
1614
- order_id: number;
1636
+ order_id: bigint;
1615
1637
  reduce_only: boolean;
1616
1638
  }[];
1617
1639
  position: {
1618
- size: number;
1619
- cost_of_trades: number;
1620
- realized_pnl: number;
1621
- cached_mark_price: number;
1622
- funding_payments_on_side: number;
1623
- funding_payments_on_position: number;
1624
- last_accum_funding_applied_per_lot: [number, 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;
1625
1647
  };
1626
1648
  user_selected_max_leverage: number;
1627
1649
  tpsls: {
1628
1650
  side: "Bid" | "Ask";
1629
- tpsl_order_id: number;
1630
- order_price: number;
1631
- trigger_price: number;
1651
+ tpsl_order_id: bigint;
1652
+ order_price: string | number;
1653
+ trigger_price: string | number;
1632
1654
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1633
1655
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1634
- active_size: number;
1635
- full_size: number;
1656
+ active_size: string | number;
1657
+ full_size: string | number;
1636
1658
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1637
- linked_tpsl_order_ids: number[];
1638
- parent_order_id?: number | undefined;
1659
+ linked_tpsl_order_ids: bigint[];
1660
+ parent_order_id?: bigint | undefined;
1639
1661
  }[];
1640
- }>>, Map<any, {
1662
+ }>>, Map<number, {
1641
1663
  orders: {
1642
- size: number;
1643
- price: number;
1664
+ size: import("decimal.js").Decimal;
1665
+ price: import("decimal.js").Decimal;
1644
1666
  side: "Bid" | "Ask";
1645
- order_id: number;
1667
+ order_id: bigint;
1646
1668
  reduce_only: boolean;
1647
1669
  }[];
1648
1670
  position: {
1649
- size: number;
1650
- cost_of_trades: number;
1651
- realized_pnl: number;
1652
- cached_mark_price: number;
1653
- funding_payments_on_side: number;
1654
- funding_payments_on_position: number;
1655
- last_accum_funding_applied_per_lot: [number, 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;
1656
1678
  };
1657
1679
  user_selected_max_leverage: number;
1658
1680
  tpsls: {
1659
1681
  side: "Bid" | "Ask";
1660
- tpsl_order_id: number;
1661
- order_price: number;
1662
- trigger_price: number;
1682
+ tpsl_order_id: bigint;
1683
+ order_price: import("decimal.js").Decimal;
1684
+ trigger_price: import("decimal.js").Decimal;
1663
1685
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1664
1686
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1665
- active_size: number;
1666
- full_size: number;
1687
+ active_size: import("decimal.js").Decimal;
1688
+ full_size: import("decimal.js").Decimal;
1667
1689
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1668
- linked_tpsl_order_ids: number[];
1669
- parent_order_id?: number | undefined;
1690
+ linked_tpsl_order_ids: bigint[];
1691
+ parent_order_id?: bigint | undefined;
1670
1692
  }[];
1671
1693
  }>, Record<string, {
1672
1694
  orders: {
1673
- size: number;
1674
- price: number;
1695
+ size: string | number;
1696
+ price: string | number;
1675
1697
  side: "Bid" | "Ask";
1676
- order_id: number;
1698
+ order_id: bigint;
1677
1699
  reduce_only: boolean;
1678
1700
  }[];
1679
1701
  position: {
1680
- size: number;
1681
- cost_of_trades: number;
1682
- realized_pnl: number;
1683
- cached_mark_price: number;
1684
- funding_payments_on_side: number;
1685
- funding_payments_on_position: number;
1686
- last_accum_funding_applied_per_lot: [number, 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;
1687
1709
  };
1688
1710
  user_selected_max_leverage: number;
1689
1711
  tpsls: {
1690
1712
  side: "Bid" | "Ask";
1691
- tpsl_order_id: number;
1692
- order_price: number;
1693
- trigger_price: number;
1713
+ tpsl_order_id: bigint;
1714
+ order_price: string | number;
1715
+ trigger_price: string | number;
1694
1716
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1695
1717
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1696
- active_size: number;
1697
- full_size: number;
1718
+ active_size: string | number;
1719
+ full_size: string | number;
1698
1720
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1699
- linked_tpsl_order_ids: number[];
1700
- parent_order_id?: number | undefined;
1721
+ linked_tpsl_order_ids: bigint[];
1722
+ parent_order_id?: bigint | undefined;
1701
1723
  }[];
1702
1724
  }>>;
1703
1725
  }, "strip", z.ZodTypeAny, {
1704
1726
  usdc_ledger: {
1705
1727
  ledger: {
1706
1728
  weights: {
1707
- initial_liability_weight: number;
1708
- maintenance_liability_weight: number;
1709
- asset_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;
1710
1732
  };
1711
- asset: number;
1712
- liability: number;
1733
+ asset: import("decimal.js").Decimal;
1734
+ liability: import("decimal.js").Decimal;
1713
1735
  };
1714
- unrealized_loss_borrow: number;
1715
- unsettled_perp_profit: number;
1736
+ unrealized_loss_borrow: import("decimal.js").Decimal;
1737
+ unsettled_perp_profit: import("decimal.js").Decimal;
1716
1738
  };
1717
- spot_ledgers: Map<any, {
1739
+ spot_ledgers: Map<number, {
1718
1740
  weights: {
1719
- initial_liability_weight: number;
1720
- maintenance_liability_weight: number;
1721
- asset_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;
1722
1744
  };
1723
- asset: number;
1724
- liability: number;
1745
+ asset: import("decimal.js").Decimal;
1746
+ liability: import("decimal.js").Decimal;
1725
1747
  }>;
1726
- perp_ledgers: Map<any, {
1748
+ perp_ledgers: Map<number, {
1727
1749
  orders: {
1728
- size: number;
1729
- price: number;
1750
+ size: import("decimal.js").Decimal;
1751
+ price: import("decimal.js").Decimal;
1730
1752
  side: "Bid" | "Ask";
1731
- order_id: number;
1753
+ order_id: bigint;
1732
1754
  reduce_only: boolean;
1733
1755
  }[];
1734
1756
  position: {
1735
- size: number;
1736
- cost_of_trades: number;
1737
- realized_pnl: number;
1738
- cached_mark_price: number;
1739
- funding_payments_on_side: number;
1740
- funding_payments_on_position: number;
1741
- last_accum_funding_applied_per_lot: [number, 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;
1742
1764
  };
1743
1765
  user_selected_max_leverage: number;
1744
1766
  tpsls: {
1745
1767
  side: "Bid" | "Ask";
1746
- tpsl_order_id: number;
1747
- order_price: number;
1748
- trigger_price: number;
1768
+ tpsl_order_id: bigint;
1769
+ order_price: import("decimal.js").Decimal;
1770
+ trigger_price: import("decimal.js").Decimal;
1749
1771
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1750
1772
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1751
- active_size: number;
1752
- full_size: number;
1773
+ active_size: import("decimal.js").Decimal;
1774
+ full_size: import("decimal.js").Decimal;
1753
1775
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1754
- linked_tpsl_order_ids: number[];
1755
- parent_order_id?: number | undefined;
1776
+ linked_tpsl_order_ids: bigint[];
1777
+ parent_order_id?: bigint | undefined;
1756
1778
  }[];
1757
1779
  }>;
1758
1780
  }, {
1759
1781
  usdc_ledger: {
1760
1782
  ledger: {
1761
1783
  weights: {
1762
- initial_liability_weight: number;
1763
- maintenance_liability_weight: number;
1764
- asset_weight: number;
1784
+ asset_weight: string | number;
1785
+ initial_liability_weight: string | number;
1786
+ maintenance_liability_weight: string | number;
1765
1787
  };
1766
- asset: number;
1767
- liability: number;
1788
+ asset: string | number;
1789
+ liability: string | number;
1768
1790
  };
1769
- unrealized_loss_borrow: number;
1770
- unsettled_perp_profit: number;
1791
+ unrealized_loss_borrow: string | number;
1792
+ unsettled_perp_profit: string | number;
1771
1793
  };
1772
1794
  spot_ledgers: Record<string, {
1773
1795
  weights: {
1774
- initial_liability_weight: number;
1775
- maintenance_liability_weight: number;
1776
- asset_weight: number;
1796
+ asset_weight: string | number;
1797
+ initial_liability_weight: string | number;
1798
+ maintenance_liability_weight: string | number;
1777
1799
  };
1778
- asset: number;
1779
- liability: number;
1800
+ asset: string | number;
1801
+ liability: string | number;
1780
1802
  }>;
1781
1803
  perp_ledgers: Record<string, {
1782
1804
  orders: {
1783
- size: number;
1784
- price: number;
1805
+ size: string | number;
1806
+ price: string | number;
1785
1807
  side: "Bid" | "Ask";
1786
- order_id: number;
1808
+ order_id: bigint;
1787
1809
  reduce_only: boolean;
1788
1810
  }[];
1789
1811
  position: {
1790
- size: number;
1791
- cost_of_trades: number;
1792
- realized_pnl: number;
1793
- cached_mark_price: number;
1794
- funding_payments_on_side: number;
1795
- funding_payments_on_position: number;
1796
- last_accum_funding_applied_per_lot: [number, 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;
1797
1819
  };
1798
1820
  user_selected_max_leverage: number;
1799
1821
  tpsls: {
1800
1822
  side: "Bid" | "Ask";
1801
- tpsl_order_id: number;
1802
- order_price: number;
1803
- trigger_price: number;
1823
+ tpsl_order_id: bigint;
1824
+ order_price: string | number;
1825
+ trigger_price: string | number;
1804
1826
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1805
1827
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1806
- active_size: number;
1807
- full_size: number;
1828
+ active_size: string | number;
1829
+ full_size: string | number;
1808
1830
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1809
- linked_tpsl_order_ids: number[];
1810
- parent_order_id?: number | undefined;
1831
+ linked_tpsl_order_ids: bigint[];
1832
+ parent_order_id?: bigint | undefined;
1811
1833
  }[];
1812
1834
  }>;
1813
1835
  }>, "many">;
@@ -1816,55 +1838,55 @@ export declare const ResponseSchemas: {
1816
1838
  usdc_ledger: {
1817
1839
  ledger: {
1818
1840
  weights: {
1819
- initial_liability_weight: number;
1820
- maintenance_liability_weight: number;
1821
- asset_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;
1822
1844
  };
1823
- asset: number;
1824
- liability: number;
1845
+ asset: import("decimal.js").Decimal;
1846
+ liability: import("decimal.js").Decimal;
1825
1847
  };
1826
- unrealized_loss_borrow: number;
1827
- unsettled_perp_profit: number;
1848
+ unrealized_loss_borrow: import("decimal.js").Decimal;
1849
+ unsettled_perp_profit: import("decimal.js").Decimal;
1828
1850
  };
1829
- spot_ledgers: Map<any, {
1851
+ spot_ledgers: Map<number, {
1830
1852
  weights: {
1831
- initial_liability_weight: number;
1832
- maintenance_liability_weight: number;
1833
- asset_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;
1834
1856
  };
1835
- asset: number;
1836
- liability: number;
1857
+ asset: import("decimal.js").Decimal;
1858
+ liability: import("decimal.js").Decimal;
1837
1859
  }>;
1838
- perp_ledgers: Map<any, {
1860
+ perp_ledgers: Map<number, {
1839
1861
  orders: {
1840
- size: number;
1841
- price: number;
1862
+ size: import("decimal.js").Decimal;
1863
+ price: import("decimal.js").Decimal;
1842
1864
  side: "Bid" | "Ask";
1843
- order_id: number;
1865
+ order_id: bigint;
1844
1866
  reduce_only: boolean;
1845
1867
  }[];
1846
1868
  position: {
1847
- size: number;
1848
- cost_of_trades: number;
1849
- realized_pnl: number;
1850
- cached_mark_price: number;
1851
- funding_payments_on_side: number;
1852
- funding_payments_on_position: number;
1853
- last_accum_funding_applied_per_lot: [number, 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;
1854
1876
  };
1855
1877
  user_selected_max_leverage: number;
1856
1878
  tpsls: {
1857
1879
  side: "Bid" | "Ask";
1858
- tpsl_order_id: number;
1859
- order_price: number;
1860
- trigger_price: number;
1880
+ tpsl_order_id: bigint;
1881
+ order_price: import("decimal.js").Decimal;
1882
+ trigger_price: import("decimal.js").Decimal;
1861
1883
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1862
1884
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1863
- active_size: number;
1864
- full_size: number;
1885
+ active_size: import("decimal.js").Decimal;
1886
+ full_size: import("decimal.js").Decimal;
1865
1887
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1866
- linked_tpsl_order_ids: number[];
1867
- parent_order_id?: number | undefined;
1888
+ linked_tpsl_order_ids: bigint[];
1889
+ parent_order_id?: bigint | undefined;
1868
1890
  }[];
1869
1891
  }>;
1870
1892
  }[];
@@ -1873,175 +1895,175 @@ export declare const ResponseSchemas: {
1873
1895
  usdc_ledger: {
1874
1896
  ledger: {
1875
1897
  weights: {
1876
- initial_liability_weight: number;
1877
- maintenance_liability_weight: number;
1878
- asset_weight: number;
1898
+ asset_weight: string | number;
1899
+ initial_liability_weight: string | number;
1900
+ maintenance_liability_weight: string | number;
1879
1901
  };
1880
- asset: number;
1881
- liability: number;
1902
+ asset: string | number;
1903
+ liability: string | number;
1882
1904
  };
1883
- unrealized_loss_borrow: number;
1884
- unsettled_perp_profit: number;
1905
+ unrealized_loss_borrow: string | number;
1906
+ unsettled_perp_profit: string | number;
1885
1907
  };
1886
1908
  spot_ledgers: Record<string, {
1887
1909
  weights: {
1888
- initial_liability_weight: number;
1889
- maintenance_liability_weight: number;
1890
- asset_weight: number;
1910
+ asset_weight: string | number;
1911
+ initial_liability_weight: string | number;
1912
+ maintenance_liability_weight: string | number;
1891
1913
  };
1892
- asset: number;
1893
- liability: number;
1914
+ asset: string | number;
1915
+ liability: string | number;
1894
1916
  }>;
1895
1917
  perp_ledgers: Record<string, {
1896
1918
  orders: {
1897
- size: number;
1898
- price: number;
1919
+ size: string | number;
1920
+ price: string | number;
1899
1921
  side: "Bid" | "Ask";
1900
- order_id: number;
1922
+ order_id: bigint;
1901
1923
  reduce_only: boolean;
1902
1924
  }[];
1903
1925
  position: {
1904
- size: number;
1905
- cost_of_trades: number;
1906
- realized_pnl: number;
1907
- cached_mark_price: number;
1908
- funding_payments_on_side: number;
1909
- funding_payments_on_position: number;
1910
- last_accum_funding_applied_per_lot: [number, 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;
1911
1933
  };
1912
1934
  user_selected_max_leverage: number;
1913
1935
  tpsls: {
1914
1936
  side: "Bid" | "Ask";
1915
- tpsl_order_id: number;
1916
- order_price: number;
1917
- trigger_price: number;
1937
+ tpsl_order_id: bigint;
1938
+ order_price: string | number;
1939
+ trigger_price: string | number;
1918
1940
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1919
1941
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1920
- active_size: number;
1921
- full_size: number;
1942
+ active_size: string | number;
1943
+ full_size: string | number;
1922
1944
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1923
- linked_tpsl_order_ids: number[];
1924
- parent_order_id?: number | undefined;
1945
+ linked_tpsl_order_ids: bigint[];
1946
+ parent_order_id?: bigint | undefined;
1925
1947
  }[];
1926
1948
  }>;
1927
1949
  }[];
1928
1950
  }>;
1929
- 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>>>;
1930
1952
  }, "strip", z.ZodTypeAny, {
1931
1953
  data: {
1932
1954
  user_accounts: {
1933
1955
  usdc_ledger: {
1934
1956
  ledger: {
1935
1957
  weights: {
1936
- initial_liability_weight: number;
1937
- maintenance_liability_weight: number;
1938
- asset_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;
1939
1961
  };
1940
- asset: number;
1941
- liability: number;
1962
+ asset: import("decimal.js").Decimal;
1963
+ liability: import("decimal.js").Decimal;
1942
1964
  };
1943
- unrealized_loss_borrow: number;
1944
- unsettled_perp_profit: number;
1965
+ unrealized_loss_borrow: import("decimal.js").Decimal;
1966
+ unsettled_perp_profit: import("decimal.js").Decimal;
1945
1967
  };
1946
- spot_ledgers: Map<any, {
1968
+ spot_ledgers: Map<number, {
1947
1969
  weights: {
1948
- initial_liability_weight: number;
1949
- maintenance_liability_weight: number;
1950
- asset_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;
1951
1973
  };
1952
- asset: number;
1953
- liability: number;
1974
+ asset: import("decimal.js").Decimal;
1975
+ liability: import("decimal.js").Decimal;
1954
1976
  }>;
1955
- perp_ledgers: Map<any, {
1977
+ perp_ledgers: Map<number, {
1956
1978
  orders: {
1957
- size: number;
1958
- price: number;
1979
+ size: import("decimal.js").Decimal;
1980
+ price: import("decimal.js").Decimal;
1959
1981
  side: "Bid" | "Ask";
1960
- order_id: number;
1982
+ order_id: bigint;
1961
1983
  reduce_only: boolean;
1962
1984
  }[];
1963
1985
  position: {
1964
- size: number;
1965
- cost_of_trades: number;
1966
- realized_pnl: number;
1967
- cached_mark_price: number;
1968
- funding_payments_on_side: number;
1969
- funding_payments_on_position: number;
1970
- last_accum_funding_applied_per_lot: [number, 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;
1971
1993
  };
1972
1994
  user_selected_max_leverage: number;
1973
1995
  tpsls: {
1974
1996
  side: "Bid" | "Ask";
1975
- tpsl_order_id: number;
1976
- order_price: number;
1977
- trigger_price: number;
1997
+ tpsl_order_id: bigint;
1998
+ order_price: import("decimal.js").Decimal;
1999
+ trigger_price: import("decimal.js").Decimal;
1978
2000
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
1979
2001
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
1980
- active_size: number;
1981
- full_size: number;
2002
+ active_size: import("decimal.js").Decimal;
2003
+ full_size: import("decimal.js").Decimal;
1982
2004
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
1983
- linked_tpsl_order_ids: number[];
1984
- parent_order_id?: number | undefined;
2005
+ linked_tpsl_order_ids: bigint[];
2006
+ parent_order_id?: bigint | undefined;
1985
2007
  }[];
1986
2008
  }>;
1987
2009
  }[];
1988
2010
  };
1989
- meta?: Map<any, unknown> | undefined;
2011
+ meta?: Map<unknown, unknown> | undefined;
1990
2012
  }, {
1991
2013
  data: {
1992
2014
  user_accounts: {
1993
2015
  usdc_ledger: {
1994
2016
  ledger: {
1995
2017
  weights: {
1996
- initial_liability_weight: number;
1997
- maintenance_liability_weight: number;
1998
- asset_weight: number;
2018
+ asset_weight: string | number;
2019
+ initial_liability_weight: string | number;
2020
+ maintenance_liability_weight: string | number;
1999
2021
  };
2000
- asset: number;
2001
- liability: number;
2022
+ asset: string | number;
2023
+ liability: string | number;
2002
2024
  };
2003
- unrealized_loss_borrow: number;
2004
- unsettled_perp_profit: number;
2025
+ unrealized_loss_borrow: string | number;
2026
+ unsettled_perp_profit: string | number;
2005
2027
  };
2006
2028
  spot_ledgers: Record<string, {
2007
2029
  weights: {
2008
- initial_liability_weight: number;
2009
- maintenance_liability_weight: number;
2010
- asset_weight: number;
2030
+ asset_weight: string | number;
2031
+ initial_liability_weight: string | number;
2032
+ maintenance_liability_weight: string | number;
2011
2033
  };
2012
- asset: number;
2013
- liability: number;
2034
+ asset: string | number;
2035
+ liability: string | number;
2014
2036
  }>;
2015
2037
  perp_ledgers: Record<string, {
2016
2038
  orders: {
2017
- size: number;
2018
- price: number;
2039
+ size: string | number;
2040
+ price: string | number;
2019
2041
  side: "Bid" | "Ask";
2020
- order_id: number;
2042
+ order_id: bigint;
2021
2043
  reduce_only: boolean;
2022
2044
  }[];
2023
2045
  position: {
2024
- size: number;
2025
- cost_of_trades: number;
2026
- realized_pnl: number;
2027
- cached_mark_price: number;
2028
- funding_payments_on_side: number;
2029
- funding_payments_on_position: number;
2030
- last_accum_funding_applied_per_lot: [number, 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;
2031
2053
  };
2032
2054
  user_selected_max_leverage: number;
2033
2055
  tpsls: {
2034
2056
  side: "Bid" | "Ask";
2035
- tpsl_order_id: number;
2036
- order_price: number;
2037
- trigger_price: number;
2057
+ tpsl_order_id: bigint;
2058
+ order_price: string | number;
2059
+ trigger_price: string | number;
2038
2060
  trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
2039
2061
  tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
2040
- active_size: number;
2041
- full_size: number;
2062
+ active_size: string | number;
2063
+ full_size: string | number;
2042
2064
  order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
2043
- linked_tpsl_order_ids: number[];
2044
- parent_order_id?: number | undefined;
2065
+ linked_tpsl_order_ids: bigint[];
2066
+ parent_order_id?: bigint | undefined;
2045
2067
  }[];
2046
2068
  }>;
2047
2069
  }[];
@@ -2054,68 +2076,68 @@ export declare const ResponseSchemas: {
2054
2076
  value: z.ZodNullable<z.ZodObject<{
2055
2077
  asset_id: z.ZodNumber;
2056
2078
  bids: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2057
- order_ids: z.ZodArray<z.ZodNumber, "many">;
2058
- 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>;
2059
2081
  }, "strip", z.ZodTypeAny, {
2060
- order_ids: number[];
2061
- total_size: number;
2082
+ order_ids: bigint[];
2083
+ total_size: import("decimal.js").Decimal;
2062
2084
  }, {
2063
- order_ids: number[];
2064
- total_size: number;
2065
- }>>, Map<any, {
2066
- order_ids: number[];
2067
- 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;
2068
2090
  }>, Record<string, {
2069
- order_ids: number[];
2070
- total_size: number;
2091
+ order_ids: bigint[];
2092
+ total_size: string | number;
2071
2093
  }>>;
2072
2094
  asks: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2073
- order_ids: z.ZodArray<z.ZodNumber, "many">;
2074
- 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>;
2075
2097
  }, "strip", z.ZodTypeAny, {
2076
- order_ids: number[];
2077
- total_size: number;
2098
+ order_ids: bigint[];
2099
+ total_size: import("decimal.js").Decimal;
2078
2100
  }, {
2079
- order_ids: number[];
2080
- total_size: number;
2081
- }>>, Map<any, {
2082
- order_ids: number[];
2083
- 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;
2084
2106
  }>, Record<string, {
2085
- order_ids: number[];
2086
- total_size: number;
2107
+ order_ids: bigint[];
2108
+ total_size: string | number;
2087
2109
  }>>;
2088
2110
  }, "strip", z.ZodTypeAny, {
2089
2111
  asset_id: number;
2090
- bids: Map<any, {
2091
- order_ids: number[];
2092
- total_size: number;
2112
+ bids: Map<string, {
2113
+ order_ids: bigint[];
2114
+ total_size: import("decimal.js").Decimal;
2093
2115
  }>;
2094
- asks: Map<any, {
2095
- order_ids: number[];
2096
- total_size: number;
2116
+ asks: Map<string, {
2117
+ order_ids: bigint[];
2118
+ total_size: import("decimal.js").Decimal;
2097
2119
  }>;
2098
2120
  }, {
2099
2121
  asset_id: number;
2100
2122
  bids: Record<string, {
2101
- order_ids: number[];
2102
- total_size: number;
2123
+ order_ids: bigint[];
2124
+ total_size: string | number;
2103
2125
  }>;
2104
2126
  asks: Record<string, {
2105
- order_ids: number[];
2106
- total_size: number;
2127
+ order_ids: bigint[];
2128
+ total_size: string | number;
2107
2129
  }>;
2108
2130
  }>>;
2109
2131
  }, "strip", z.ZodTypeAny, {
2110
2132
  value: {
2111
2133
  asset_id: number;
2112
- bids: Map<any, {
2113
- order_ids: number[];
2114
- total_size: number;
2134
+ bids: Map<string, {
2135
+ order_ids: bigint[];
2136
+ total_size: import("decimal.js").Decimal;
2115
2137
  }>;
2116
- asks: Map<any, {
2117
- order_ids: number[];
2118
- total_size: number;
2138
+ asks: Map<string, {
2139
+ order_ids: bigint[];
2140
+ total_size: import("decimal.js").Decimal;
2119
2141
  }>;
2120
2142
  } | null;
2121
2143
  key: number;
@@ -2123,44 +2145,44 @@ export declare const ResponseSchemas: {
2123
2145
  value: {
2124
2146
  asset_id: number;
2125
2147
  bids: Record<string, {
2126
- order_ids: number[];
2127
- total_size: number;
2148
+ order_ids: bigint[];
2149
+ total_size: string | number;
2128
2150
  }>;
2129
2151
  asks: Record<string, {
2130
- order_ids: number[];
2131
- total_size: number;
2152
+ order_ids: bigint[];
2153
+ total_size: string | number;
2132
2154
  }>;
2133
2155
  } | null;
2134
2156
  key: number;
2135
2157
  }>;
2136
- 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>>>;
2137
2159
  }, "strip", z.ZodTypeAny, {
2138
2160
  data: {
2139
2161
  value: {
2140
2162
  asset_id: number;
2141
- bids: Map<any, {
2142
- order_ids: number[];
2143
- total_size: number;
2163
+ bids: Map<string, {
2164
+ order_ids: bigint[];
2165
+ total_size: import("decimal.js").Decimal;
2144
2166
  }>;
2145
- asks: Map<any, {
2146
- order_ids: number[];
2147
- total_size: number;
2167
+ asks: Map<string, {
2168
+ order_ids: bigint[];
2169
+ total_size: import("decimal.js").Decimal;
2148
2170
  }>;
2149
2171
  } | null;
2150
2172
  key: number;
2151
2173
  };
2152
- meta?: Map<any, unknown> | undefined;
2174
+ meta?: Map<unknown, unknown> | undefined;
2153
2175
  }, {
2154
2176
  data: {
2155
2177
  value: {
2156
2178
  asset_id: number;
2157
2179
  bids: Record<string, {
2158
- order_ids: number[];
2159
- total_size: number;
2180
+ order_ids: bigint[];
2181
+ total_size: string | number;
2160
2182
  }>;
2161
2183
  asks: Record<string, {
2162
- order_ids: number[];
2163
- total_size: number;
2184
+ order_ids: bigint[];
2185
+ total_size: string | number;
2164
2186
  }>;
2165
2187
  } | null;
2166
2188
  key: number;
@@ -2172,147 +2194,147 @@ export declare const ResponseSchemas: {
2172
2194
  value: z.ZodNullable<z.ZodObject<{
2173
2195
  pricing_frequency_seconds: z.ZodNumber;
2174
2196
  prices_info: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2175
- mark_price: z.ZodNumber;
2176
- oracle_price: z.ZodNumber;
2177
- 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;
2178
2200
  }, "strip", z.ZodTypeAny, {
2179
- mark_price: number;
2180
- oracle_price: number;
2181
- publish_timestamp: number;
2201
+ mark_price: import("decimal.js").Decimal;
2202
+ oracle_price: import("decimal.js").Decimal;
2203
+ publish_timestamp: bigint;
2182
2204
  }, {
2183
- mark_price: number;
2184
- oracle_price: number;
2185
- publish_timestamp: number;
2186
- }>>, Map<any, {
2187
- mark_price: number;
2188
- oracle_price: number;
2189
- 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;
2190
2212
  }>, Record<string, {
2191
- mark_price: number;
2192
- oracle_price: number;
2193
- publish_timestamp: number;
2213
+ mark_price: string | number;
2214
+ oracle_price: string | number;
2215
+ publish_timestamp: bigint;
2194
2216
  }>>;
2195
2217
  premium_index: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2196
- weighted_premium_sum: z.ZodNumber;
2197
- duration_sum: z.ZodNumber;
2198
- 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>;
2199
2221
  }, "strip", z.ZodTypeAny, {
2200
- last_update_timestamp: number | null;
2201
- weighted_premium_sum: number;
2202
- duration_sum: number;
2222
+ last_update_timestamp: bigint | null;
2223
+ weighted_premium_sum: import("decimal.js").Decimal;
2224
+ duration_sum: bigint;
2203
2225
  }, {
2204
- last_update_timestamp: number | null;
2205
- weighted_premium_sum: number;
2206
- duration_sum: number;
2207
- }>>, Map<any, {
2208
- last_update_timestamp: number | null;
2209
- weighted_premium_sum: number;
2210
- 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;
2211
2233
  }>, Record<string, {
2212
- last_update_timestamp: number | null;
2213
- weighted_premium_sum: number;
2214
- duration_sum: number;
2234
+ last_update_timestamp: bigint | null;
2235
+ weighted_premium_sum: string | number;
2236
+ duration_sum: bigint;
2215
2237
  }>>;
2216
- funding_rates: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>, Map<any, [number, number]>, Record<string, [number, number]>>;
2217
- 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]>>;
2218
2240
  }, "strip", z.ZodTypeAny, {
2219
2241
  pricing_frequency_seconds: number;
2220
- prices_info: Map<any, {
2221
- mark_price: number;
2222
- oracle_price: number;
2223
- 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;
2224
2246
  }>;
2225
- premium_index: Map<any, {
2226
- last_update_timestamp: number | null;
2227
- weighted_premium_sum: number;
2228
- 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;
2229
2251
  }>;
2230
- funding_rates: Map<any, [number, number]>;
2231
- 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]>;
2232
2254
  }, {
2233
2255
  pricing_frequency_seconds: number;
2234
2256
  prices_info: Record<string, {
2235
- mark_price: number;
2236
- oracle_price: number;
2237
- publish_timestamp: number;
2257
+ mark_price: string | number;
2258
+ oracle_price: string | number;
2259
+ publish_timestamp: bigint;
2238
2260
  }>;
2239
2261
  premium_index: Record<string, {
2240
- last_update_timestamp: number | null;
2241
- weighted_premium_sum: number;
2242
- duration_sum: number;
2262
+ last_update_timestamp: bigint | null;
2263
+ weighted_premium_sum: string | number;
2264
+ duration_sum: bigint;
2243
2265
  }>;
2244
- funding_rates: Record<string, [number, number]>;
2245
- 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]>;
2246
2268
  }>>;
2247
2269
  }, "strip", z.ZodTypeAny, {
2248
2270
  value: {
2249
2271
  pricing_frequency_seconds: number;
2250
- prices_info: Map<any, {
2251
- mark_price: number;
2252
- oracle_price: number;
2253
- 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;
2254
2276
  }>;
2255
- premium_index: Map<any, {
2256
- last_update_timestamp: number | null;
2257
- weighted_premium_sum: number;
2258
- 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;
2259
2281
  }>;
2260
- funding_rates: Map<any, [number, number]>;
2261
- 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]>;
2262
2284
  } | null;
2263
2285
  }, {
2264
2286
  value: {
2265
2287
  pricing_frequency_seconds: number;
2266
2288
  prices_info: Record<string, {
2267
- mark_price: number;
2268
- oracle_price: number;
2269
- publish_timestamp: number;
2289
+ mark_price: string | number;
2290
+ oracle_price: string | number;
2291
+ publish_timestamp: bigint;
2270
2292
  }>;
2271
2293
  premium_index: Record<string, {
2272
- last_update_timestamp: number | null;
2273
- weighted_premium_sum: number;
2274
- duration_sum: number;
2294
+ last_update_timestamp: bigint | null;
2295
+ weighted_premium_sum: string | number;
2296
+ duration_sum: bigint;
2275
2297
  }>;
2276
- funding_rates: Record<string, [number, number]>;
2277
- 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]>;
2278
2300
  } | null;
2279
2301
  }>;
2280
- 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>>>;
2281
2303
  }, "strip", z.ZodTypeAny, {
2282
2304
  data: {
2283
2305
  value: {
2284
2306
  pricing_frequency_seconds: number;
2285
- prices_info: Map<any, {
2286
- mark_price: number;
2287
- oracle_price: number;
2288
- 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;
2289
2311
  }>;
2290
- premium_index: Map<any, {
2291
- last_update_timestamp: number | null;
2292
- weighted_premium_sum: number;
2293
- 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;
2294
2316
  }>;
2295
- funding_rates: Map<any, [number, number]>;
2296
- 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]>;
2297
2319
  } | null;
2298
2320
  };
2299
- meta?: Map<any, unknown> | undefined;
2321
+ meta?: Map<unknown, unknown> | undefined;
2300
2322
  }, {
2301
2323
  data: {
2302
2324
  value: {
2303
2325
  pricing_frequency_seconds: number;
2304
2326
  prices_info: Record<string, {
2305
- mark_price: number;
2306
- oracle_price: number;
2307
- publish_timestamp: number;
2327
+ mark_price: string | number;
2328
+ oracle_price: string | number;
2329
+ publish_timestamp: bigint;
2308
2330
  }>;
2309
2331
  premium_index: Record<string, {
2310
- last_update_timestamp: number | null;
2311
- weighted_premium_sum: number;
2312
- duration_sum: number;
2332
+ last_update_timestamp: bigint | null;
2333
+ weighted_premium_sum: string | number;
2334
+ duration_sum: bigint;
2313
2335
  }>;
2314
- funding_rates: Record<string, [number, number]>;
2315
- 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]>;
2316
2338
  } | null;
2317
2339
  };
2318
2340
  meta?: Record<string, unknown> | undefined;
@@ -2320,40 +2342,40 @@ export declare const ResponseSchemas: {
2320
2342
  readonly UsdcPnlPool: z.ZodObject<{
2321
2343
  data: z.ZodObject<{
2322
2344
  value: z.ZodNullable<z.ZodObject<{
2323
- usdc_token_amount: z.ZodNumber;
2324
- 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>>;
2325
2347
  }, "strip", z.ZodTypeAny, {
2326
- usdc_token_amount: number;
2327
- external_deposits: Record<string, number>;
2348
+ usdc_token_amount: import("decimal.js").Decimal;
2349
+ external_deposits: Map<string, import("decimal.js").Decimal>;
2328
2350
  }, {
2329
- usdc_token_amount: number;
2330
- external_deposits: Record<string, number>;
2351
+ usdc_token_amount: string | number;
2352
+ external_deposits: Record<string, string | number>;
2331
2353
  }>>;
2332
2354
  }, "strip", z.ZodTypeAny, {
2333
2355
  value: {
2334
- usdc_token_amount: number;
2335
- external_deposits: Record<string, number>;
2356
+ usdc_token_amount: import("decimal.js").Decimal;
2357
+ external_deposits: Map<string, import("decimal.js").Decimal>;
2336
2358
  } | null;
2337
2359
  }, {
2338
2360
  value: {
2339
- usdc_token_amount: number;
2340
- external_deposits: Record<string, number>;
2361
+ usdc_token_amount: string | number;
2362
+ external_deposits: Record<string, string | number>;
2341
2363
  } | null;
2342
2364
  }>;
2343
- 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>>>;
2344
2366
  }, "strip", z.ZodTypeAny, {
2345
2367
  data: {
2346
2368
  value: {
2347
- usdc_token_amount: number;
2348
- external_deposits: Record<string, number>;
2369
+ usdc_token_amount: import("decimal.js").Decimal;
2370
+ external_deposits: Map<string, import("decimal.js").Decimal>;
2349
2371
  } | null;
2350
2372
  };
2351
- meta?: Map<any, unknown> | undefined;
2373
+ meta?: Map<unknown, unknown> | undefined;
2352
2374
  }, {
2353
2375
  data: {
2354
2376
  value: {
2355
- usdc_token_amount: number;
2356
- external_deposits: Record<string, number>;
2377
+ usdc_token_amount: string | number;
2378
+ external_deposits: Record<string, string | number>;
2357
2379
  } | null;
2358
2380
  };
2359
2381
  meta?: Record<string, unknown> | undefined;
@@ -2361,47 +2383,47 @@ export declare const ResponseSchemas: {
2361
2383
  readonly UsdcInsuranceFund: z.ZodObject<{
2362
2384
  data: z.ZodObject<{
2363
2385
  value: z.ZodNullable<z.ZodObject<{
2364
- usdc_token_amount: z.ZodNumber;
2365
- external_deposits: z.ZodRecord<z.ZodString, z.ZodNumber>;
2366
- 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>;
2367
2389
  }, "strip", z.ZodTypeAny, {
2368
- usdc_token_amount: number;
2369
- external_deposits: Record<string, number>;
2370
- 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;
2371
2393
  }, {
2372
- usdc_token_amount: number;
2373
- external_deposits: Record<string, number>;
2374
- 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;
2375
2397
  }>>;
2376
2398
  }, "strip", z.ZodTypeAny, {
2377
2399
  value: {
2378
- usdc_token_amount: number;
2379
- external_deposits: Record<string, number>;
2380
- 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;
2381
2403
  } | null;
2382
2404
  }, {
2383
2405
  value: {
2384
- usdc_token_amount: number;
2385
- external_deposits: Record<string, number>;
2386
- 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;
2387
2409
  } | null;
2388
2410
  }>;
2389
- 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>>>;
2390
2412
  }, "strip", z.ZodTypeAny, {
2391
2413
  data: {
2392
2414
  value: {
2393
- usdc_token_amount: number;
2394
- external_deposits: Record<string, number>;
2395
- 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;
2396
2418
  } | null;
2397
2419
  };
2398
- meta?: Map<any, unknown> | undefined;
2420
+ meta?: Map<unknown, unknown> | undefined;
2399
2421
  }, {
2400
2422
  data: {
2401
2423
  value: {
2402
- usdc_token_amount: number;
2403
- external_deposits: Record<string, number>;
2404
- 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;
2405
2427
  } | null;
2406
2428
  };
2407
2429
  meta?: Record<string, unknown> | undefined;
@@ -2411,294 +2433,324 @@ export declare const ResponseSchemas: {
2411
2433
  market: z.ZodObject<{
2412
2434
  market: z.ZodObject<{
2413
2435
  is_active: z.ZodBoolean;
2414
- last_update_timestamp: z.ZodNumber;
2436
+ last_update_timestamp: z.ZodBigInt;
2415
2437
  decimals: z.ZodNumber;
2416
2438
  risk_params: z.ZodObject<{
2417
- weight: z.ZodNumber;
2418
- initial_liability_weight: z.ZodNumber;
2419
- maintenance_liability_weight: z.ZodNumber;
2420
- deposit_limit: z.ZodNumber;
2421
- borrow_limit: z.ZodNumber;
2422
- liquidation_reward_ratio: z.ZodNumber;
2423
- liability_liquidation_limit_ratio: z.ZodNumber;
2439
+ weights: z.ZodObject<{
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
+ }, "strip", z.ZodTypeAny, {
2444
+ asset_weight: import("decimal.js").Decimal;
2445
+ initial_liability_weight: import("decimal.js").Decimal;
2446
+ maintenance_liability_weight: import("decimal.js").Decimal;
2447
+ }, {
2448
+ asset_weight: string | number;
2449
+ initial_liability_weight: string | number;
2450
+ maintenance_liability_weight: string | number;
2451
+ }>;
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>;
2424
2456
  }, "strip", z.ZodTypeAny, {
2425
- weight: number;
2426
- initial_liability_weight: number;
2427
- maintenance_liability_weight: number;
2428
- deposit_limit: number;
2429
- borrow_limit: number;
2430
- liquidation_reward_ratio: number;
2431
- liability_liquidation_limit_ratio: number;
2457
+ weights: {
2458
+ asset_weight: import("decimal.js").Decimal;
2459
+ initial_liability_weight: import("decimal.js").Decimal;
2460
+ maintenance_liability_weight: import("decimal.js").Decimal;
2461
+ };
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;
2432
2466
  }, {
2433
- weight: number;
2434
- initial_liability_weight: number;
2435
- maintenance_liability_weight: number;
2436
- deposit_limit: number;
2437
- borrow_limit: number;
2438
- liquidation_reward_ratio: number;
2439
- liability_liquidation_limit_ratio: number;
2467
+ weights: {
2468
+ asset_weight: string | number;
2469
+ initial_liability_weight: string | number;
2470
+ maintenance_liability_weight: string | number;
2471
+ };
2472
+ deposit_limit: string | number;
2473
+ borrow_limit: string | number;
2474
+ liquidation_reward_ratio: string | number;
2475
+ liability_liquidation_limit_ratio: string | number;
2440
2476
  }>;
2441
2477
  rate_params: z.ZodObject<{
2442
- optimal_utilisation_rate: z.ZodNumber;
2443
- min_borrow_rate: z.ZodNumber;
2444
- optimal_borrow_rate: z.ZodNumber;
2445
- 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>;
2446
2482
  }, "strip", z.ZodTypeAny, {
2447
- optimal_utilisation_rate: number;
2448
- min_borrow_rate: number;
2449
- optimal_borrow_rate: number;
2450
- 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;
2451
2487
  }, {
2452
- optimal_utilisation_rate: number;
2453
- min_borrow_rate: number;
2454
- optimal_borrow_rate: number;
2455
- 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;
2456
2492
  }>;
2457
- available_amount: z.ZodNumber;
2458
- borrowed_amount: z.ZodNumber;
2459
- cumulative_deposit_rate: z.ZodNumber;
2460
- cumulative_borrow_rate: z.ZodNumber;
2461
- 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>;
2462
2498
  }, "strip", z.ZodTypeAny, {
2463
2499
  is_active: boolean;
2464
- last_update_timestamp: number;
2500
+ last_update_timestamp: bigint;
2465
2501
  decimals: number;
2466
2502
  risk_params: {
2467
- weight: number;
2468
- initial_liability_weight: number;
2469
- maintenance_liability_weight: number;
2470
- deposit_limit: number;
2471
- borrow_limit: number;
2472
- liquidation_reward_ratio: number;
2473
- liability_liquidation_limit_ratio: number;
2503
+ weights: {
2504
+ asset_weight: import("decimal.js").Decimal;
2505
+ initial_liability_weight: import("decimal.js").Decimal;
2506
+ maintenance_liability_weight: import("decimal.js").Decimal;
2507
+ };
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;
2474
2512
  };
2475
2513
  rate_params: {
2476
- optimal_utilisation_rate: number;
2477
- min_borrow_rate: number;
2478
- optimal_borrow_rate: number;
2479
- 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;
2480
2518
  };
2481
- available_amount: number;
2482
- borrowed_amount: number;
2483
- cumulative_deposit_rate: number;
2484
- cumulative_borrow_rate: number;
2485
- 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;
2486
2524
  }, {
2487
2525
  is_active: boolean;
2488
- last_update_timestamp: number;
2526
+ last_update_timestamp: bigint;
2489
2527
  decimals: number;
2490
2528
  risk_params: {
2491
- weight: number;
2492
- initial_liability_weight: number;
2493
- maintenance_liability_weight: number;
2494
- deposit_limit: number;
2495
- borrow_limit: number;
2496
- liquidation_reward_ratio: number;
2497
- liability_liquidation_limit_ratio: number;
2529
+ weights: {
2530
+ asset_weight: string | number;
2531
+ initial_liability_weight: string | number;
2532
+ maintenance_liability_weight: string | number;
2533
+ };
2534
+ deposit_limit: string | number;
2535
+ borrow_limit: string | number;
2536
+ liquidation_reward_ratio: string | number;
2537
+ liability_liquidation_limit_ratio: string | number;
2498
2538
  };
2499
2539
  rate_params: {
2500
- optimal_utilisation_rate: number;
2501
- min_borrow_rate: number;
2502
- optimal_borrow_rate: number;
2503
- 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;
2504
2544
  };
2505
- available_amount: number;
2506
- borrowed_amount: number;
2507
- cumulative_deposit_rate: number;
2508
- cumulative_borrow_rate: number;
2509
- 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;
2510
2550
  }>;
2511
- utilisation_rate: z.ZodNumber;
2512
- current_deposit_rate: z.ZodNumber;
2513
- 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>;
2514
2554
  }, "strip", z.ZodTypeAny, {
2515
2555
  market: {
2516
2556
  is_active: boolean;
2517
- last_update_timestamp: number;
2557
+ last_update_timestamp: bigint;
2518
2558
  decimals: number;
2519
2559
  risk_params: {
2520
- weight: number;
2521
- initial_liability_weight: number;
2522
- maintenance_liability_weight: number;
2523
- deposit_limit: number;
2524
- borrow_limit: number;
2525
- liquidation_reward_ratio: number;
2526
- liability_liquidation_limit_ratio: number;
2560
+ weights: {
2561
+ asset_weight: import("decimal.js").Decimal;
2562
+ initial_liability_weight: import("decimal.js").Decimal;
2563
+ maintenance_liability_weight: import("decimal.js").Decimal;
2564
+ };
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;
2527
2569
  };
2528
2570
  rate_params: {
2529
- optimal_utilisation_rate: number;
2530
- min_borrow_rate: number;
2531
- optimal_borrow_rate: number;
2532
- 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;
2533
2575
  };
2534
- available_amount: number;
2535
- borrowed_amount: number;
2536
- cumulative_deposit_rate: number;
2537
- cumulative_borrow_rate: number;
2538
- 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;
2539
2581
  };
2540
- utilisation_rate: number;
2541
- current_deposit_rate: number;
2542
- 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;
2543
2585
  }, {
2544
2586
  market: {
2545
2587
  is_active: boolean;
2546
- last_update_timestamp: number;
2588
+ last_update_timestamp: bigint;
2547
2589
  decimals: number;
2548
2590
  risk_params: {
2549
- weight: number;
2550
- initial_liability_weight: number;
2551
- maintenance_liability_weight: number;
2552
- deposit_limit: number;
2553
- borrow_limit: number;
2554
- liquidation_reward_ratio: number;
2555
- liability_liquidation_limit_ratio: number;
2591
+ weights: {
2592
+ asset_weight: string | number;
2593
+ initial_liability_weight: string | number;
2594
+ maintenance_liability_weight: string | number;
2595
+ };
2596
+ deposit_limit: string | number;
2597
+ borrow_limit: string | number;
2598
+ liquidation_reward_ratio: string | number;
2599
+ liability_liquidation_limit_ratio: string | number;
2556
2600
  };
2557
2601
  rate_params: {
2558
- optimal_utilisation_rate: number;
2559
- min_borrow_rate: number;
2560
- optimal_borrow_rate: number;
2561
- 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;
2562
2606
  };
2563
- available_amount: number;
2564
- borrowed_amount: number;
2565
- cumulative_deposit_rate: number;
2566
- cumulative_borrow_rate: number;
2567
- 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;
2568
2612
  };
2569
- utilisation_rate: number;
2570
- current_deposit_rate: number;
2571
- current_borrow_rate: number;
2613
+ utilisation_rate: string | number;
2614
+ current_deposit_rate: string | number;
2615
+ current_borrow_rate: string | number;
2572
2616
  }>;
2573
2617
  }, "strip", z.ZodTypeAny, {
2574
2618
  market: {
2575
2619
  market: {
2576
2620
  is_active: boolean;
2577
- last_update_timestamp: number;
2621
+ last_update_timestamp: bigint;
2578
2622
  decimals: number;
2579
2623
  risk_params: {
2580
- weight: number;
2581
- initial_liability_weight: number;
2582
- maintenance_liability_weight: number;
2583
- deposit_limit: number;
2584
- borrow_limit: number;
2585
- liquidation_reward_ratio: number;
2586
- liability_liquidation_limit_ratio: number;
2624
+ weights: {
2625
+ asset_weight: import("decimal.js").Decimal;
2626
+ initial_liability_weight: import("decimal.js").Decimal;
2627
+ maintenance_liability_weight: import("decimal.js").Decimal;
2628
+ };
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;
2587
2633
  };
2588
2634
  rate_params: {
2589
- optimal_utilisation_rate: number;
2590
- min_borrow_rate: number;
2591
- optimal_borrow_rate: number;
2592
- 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;
2593
2639
  };
2594
- available_amount: number;
2595
- borrowed_amount: number;
2596
- cumulative_deposit_rate: number;
2597
- cumulative_borrow_rate: number;
2598
- 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;
2599
2645
  };
2600
- utilisation_rate: number;
2601
- current_deposit_rate: number;
2602
- 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;
2603
2649
  };
2604
2650
  }, {
2605
2651
  market: {
2606
2652
  market: {
2607
2653
  is_active: boolean;
2608
- last_update_timestamp: number;
2654
+ last_update_timestamp: bigint;
2609
2655
  decimals: number;
2610
2656
  risk_params: {
2611
- weight: number;
2612
- initial_liability_weight: number;
2613
- maintenance_liability_weight: number;
2614
- deposit_limit: number;
2615
- borrow_limit: number;
2616
- liquidation_reward_ratio: number;
2617
- liability_liquidation_limit_ratio: number;
2657
+ weights: {
2658
+ asset_weight: string | number;
2659
+ initial_liability_weight: string | number;
2660
+ maintenance_liability_weight: string | number;
2661
+ };
2662
+ deposit_limit: string | number;
2663
+ borrow_limit: string | number;
2664
+ liquidation_reward_ratio: string | number;
2665
+ liability_liquidation_limit_ratio: string | number;
2618
2666
  };
2619
2667
  rate_params: {
2620
- optimal_utilisation_rate: number;
2621
- min_borrow_rate: number;
2622
- optimal_borrow_rate: number;
2623
- 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;
2624
2672
  };
2625
- available_amount: number;
2626
- borrowed_amount: number;
2627
- cumulative_deposit_rate: number;
2628
- cumulative_borrow_rate: number;
2629
- 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;
2630
2678
  };
2631
- utilisation_rate: number;
2632
- current_deposit_rate: number;
2633
- current_borrow_rate: number;
2679
+ utilisation_rate: string | number;
2680
+ current_deposit_rate: string | number;
2681
+ current_borrow_rate: string | number;
2634
2682
  };
2635
2683
  }>;
2636
- 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>>>;
2637
2685
  }, "strip", z.ZodTypeAny, {
2638
2686
  data: {
2639
2687
  market: {
2640
2688
  market: {
2641
2689
  is_active: boolean;
2642
- last_update_timestamp: number;
2690
+ last_update_timestamp: bigint;
2643
2691
  decimals: number;
2644
2692
  risk_params: {
2645
- weight: number;
2646
- initial_liability_weight: number;
2647
- maintenance_liability_weight: number;
2648
- deposit_limit: number;
2649
- borrow_limit: number;
2650
- liquidation_reward_ratio: number;
2651
- liability_liquidation_limit_ratio: number;
2693
+ weights: {
2694
+ asset_weight: import("decimal.js").Decimal;
2695
+ initial_liability_weight: import("decimal.js").Decimal;
2696
+ maintenance_liability_weight: import("decimal.js").Decimal;
2697
+ };
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;
2652
2702
  };
2653
2703
  rate_params: {
2654
- optimal_utilisation_rate: number;
2655
- min_borrow_rate: number;
2656
- optimal_borrow_rate: number;
2657
- 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;
2658
2708
  };
2659
- available_amount: number;
2660
- borrowed_amount: number;
2661
- cumulative_deposit_rate: number;
2662
- cumulative_borrow_rate: number;
2663
- 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;
2664
2714
  };
2665
- utilisation_rate: number;
2666
- current_deposit_rate: number;
2667
- 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;
2668
2718
  };
2669
2719
  };
2670
- meta?: Map<any, unknown> | undefined;
2720
+ meta?: Map<unknown, unknown> | undefined;
2671
2721
  }, {
2672
2722
  data: {
2673
2723
  market: {
2674
2724
  market: {
2675
2725
  is_active: boolean;
2676
- last_update_timestamp: number;
2726
+ last_update_timestamp: bigint;
2677
2727
  decimals: number;
2678
2728
  risk_params: {
2679
- weight: number;
2680
- initial_liability_weight: number;
2681
- maintenance_liability_weight: number;
2682
- deposit_limit: number;
2683
- borrow_limit: number;
2684
- liquidation_reward_ratio: number;
2685
- liability_liquidation_limit_ratio: number;
2729
+ weights: {
2730
+ asset_weight: string | number;
2731
+ initial_liability_weight: string | number;
2732
+ maintenance_liability_weight: string | number;
2733
+ };
2734
+ deposit_limit: string | number;
2735
+ borrow_limit: string | number;
2736
+ liquidation_reward_ratio: string | number;
2737
+ liability_liquidation_limit_ratio: string | number;
2686
2738
  };
2687
2739
  rate_params: {
2688
- optimal_utilisation_rate: number;
2689
- min_borrow_rate: number;
2690
- optimal_borrow_rate: number;
2691
- 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;
2692
2744
  };
2693
- available_amount: number;
2694
- borrowed_amount: number;
2695
- cumulative_deposit_rate: number;
2696
- cumulative_borrow_rate: number;
2697
- 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;
2698
2750
  };
2699
- utilisation_rate: number;
2700
- current_deposit_rate: number;
2701
- current_borrow_rate: number;
2751
+ utilisation_rate: string | number;
2752
+ current_deposit_rate: string | number;
2753
+ current_borrow_rate: string | number;
2702
2754
  };
2703
2755
  };
2704
2756
  meta?: Record<string, unknown> | undefined;
@@ -2708,91 +2760,91 @@ export declare const ResponseSchemas: {
2708
2760
  key: z.ZodNumber;
2709
2761
  value: z.ZodNullable<z.ZodObject<{
2710
2762
  is_active: z.ZodBoolean;
2711
- min_tick_size: z.ZodNumber;
2712
- min_lot_size: z.ZodNumber;
2713
- min_interest_rate_clamp: z.ZodNumber;
2714
- max_interest_rate_clamp: z.ZodNumber;
2715
- min_funding_rate_clamp: z.ZodNumber;
2716
- max_funding_rate_clamp: z.ZodNumber;
2717
- impact_margin: z.ZodNumber;
2718
- 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>;
2719
2771
  }, "strip", z.ZodTypeAny, {
2720
2772
  is_active: boolean;
2721
- min_tick_size: number;
2722
- min_lot_size: number;
2723
- min_interest_rate_clamp: number;
2724
- max_interest_rate_clamp: number;
2725
- min_funding_rate_clamp: number;
2726
- max_funding_rate_clamp: number;
2727
- impact_margin: number;
2728
- 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;
2729
2781
  }, {
2730
2782
  is_active: boolean;
2731
- min_tick_size: number;
2732
- min_lot_size: number;
2733
- min_interest_rate_clamp: number;
2734
- max_interest_rate_clamp: number;
2735
- min_funding_rate_clamp: number;
2736
- max_funding_rate_clamp: number;
2737
- impact_margin: number;
2738
- 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;
2739
2791
  }>>;
2740
2792
  }, "strip", z.ZodTypeAny, {
2741
2793
  value: {
2742
2794
  is_active: boolean;
2743
- min_tick_size: number;
2744
- min_lot_size: number;
2745
- min_interest_rate_clamp: number;
2746
- max_interest_rate_clamp: number;
2747
- min_funding_rate_clamp: number;
2748
- max_funding_rate_clamp: number;
2749
- impact_margin: number;
2750
- 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;
2751
2803
  } | null;
2752
2804
  key: number;
2753
2805
  }, {
2754
2806
  value: {
2755
2807
  is_active: boolean;
2756
- min_tick_size: number;
2757
- min_lot_size: number;
2758
- min_interest_rate_clamp: number;
2759
- max_interest_rate_clamp: number;
2760
- min_funding_rate_clamp: number;
2761
- max_funding_rate_clamp: number;
2762
- impact_margin: number;
2763
- 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;
2764
2816
  } | null;
2765
2817
  key: number;
2766
2818
  }>;
2767
- 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>>>;
2768
2820
  }, "strip", z.ZodTypeAny, {
2769
2821
  data: {
2770
2822
  value: {
2771
2823
  is_active: boolean;
2772
- min_tick_size: number;
2773
- min_lot_size: number;
2774
- min_interest_rate_clamp: number;
2775
- max_interest_rate_clamp: number;
2776
- min_funding_rate_clamp: number;
2777
- max_funding_rate_clamp: number;
2778
- impact_margin: number;
2779
- 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;
2780
2832
  } | null;
2781
2833
  key: number;
2782
2834
  };
2783
- meta?: Map<any, unknown> | undefined;
2835
+ meta?: Map<unknown, unknown> | undefined;
2784
2836
  }, {
2785
2837
  data: {
2786
2838
  value: {
2787
2839
  is_active: boolean;
2788
- min_tick_size: number;
2789
- min_lot_size: number;
2790
- min_interest_rate_clamp: number;
2791
- max_interest_rate_clamp: number;
2792
- min_funding_rate_clamp: number;
2793
- max_funding_rate_clamp: number;
2794
- impact_margin: number;
2795
- 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;
2796
2848
  } | null;
2797
2849
  key: number;
2798
2850
  };
@@ -2804,133 +2856,133 @@ export declare const ResponseSchemas: {
2804
2856
  perp_leverage_tables: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2805
2857
  tiers: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
2806
2858
  max_leverage: z.ZodNumber;
2807
- mmr: z.ZodNumber;
2808
- 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>;
2809
2861
  }, "strip", z.ZodTypeAny, {
2810
2862
  max_leverage: number;
2811
- mmr: number;
2812
- maintenance_amount: number;
2863
+ mmr: import("decimal.js").Decimal;
2864
+ maintenance_amount: import("decimal.js").Decimal;
2813
2865
  }, {
2814
2866
  max_leverage: number;
2815
- mmr: number;
2816
- maintenance_amount: number;
2817
- }>>, Map<any, {
2867
+ mmr: string | number;
2868
+ maintenance_amount: string | number;
2869
+ }>>, Map<string, {
2818
2870
  max_leverage: number;
2819
- mmr: number;
2820
- maintenance_amount: number;
2871
+ mmr: import("decimal.js").Decimal;
2872
+ maintenance_amount: import("decimal.js").Decimal;
2821
2873
  }>, Record<string, {
2822
2874
  max_leverage: number;
2823
- mmr: number;
2824
- maintenance_amount: number;
2875
+ mmr: string | number;
2876
+ maintenance_amount: string | number;
2825
2877
  }>>;
2826
2878
  }, "strip", z.ZodTypeAny, {
2827
- tiers: Map<any, {
2879
+ tiers: Map<string, {
2828
2880
  max_leverage: number;
2829
- mmr: number;
2830
- maintenance_amount: number;
2881
+ mmr: import("decimal.js").Decimal;
2882
+ maintenance_amount: import("decimal.js").Decimal;
2831
2883
  }>;
2832
2884
  }, {
2833
2885
  tiers: Record<string, {
2834
2886
  max_leverage: number;
2835
- mmr: number;
2836
- maintenance_amount: number;
2887
+ mmr: string | number;
2888
+ maintenance_amount: string | number;
2837
2889
  }>;
2838
- }>>, Map<any, {
2839
- tiers: Map<any, {
2890
+ }>>, Map<number, {
2891
+ tiers: Map<string, {
2840
2892
  max_leverage: number;
2841
- mmr: number;
2842
- maintenance_amount: number;
2893
+ mmr: import("decimal.js").Decimal;
2894
+ maintenance_amount: import("decimal.js").Decimal;
2843
2895
  }>;
2844
2896
  }>, Record<string, {
2845
2897
  tiers: Record<string, {
2846
2898
  max_leverage: number;
2847
- mmr: number;
2848
- maintenance_amount: number;
2899
+ mmr: string | number;
2900
+ maintenance_amount: string | number;
2849
2901
  }>;
2850
2902
  }>>;
2851
- liquidation_ioc_buffer: z.ZodNumber;
2852
- backstop_liquidation_threshold: z.ZodNumber;
2853
- 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>;
2854
2906
  }, "strip", z.ZodTypeAny, {
2855
- perp_leverage_tables: Map<any, {
2856
- tiers: Map<any, {
2907
+ perp_leverage_tables: Map<number, {
2908
+ tiers: Map<string, {
2857
2909
  max_leverage: number;
2858
- mmr: number;
2859
- maintenance_amount: number;
2910
+ mmr: import("decimal.js").Decimal;
2911
+ maintenance_amount: import("decimal.js").Decimal;
2860
2912
  }>;
2861
2913
  }>;
2862
- liquidation_ioc_buffer: number;
2863
- backstop_liquidation_threshold: number;
2864
- 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;
2865
2917
  }, {
2866
2918
  perp_leverage_tables: Record<string, {
2867
2919
  tiers: Record<string, {
2868
2920
  max_leverage: number;
2869
- mmr: number;
2870
- maintenance_amount: number;
2921
+ mmr: string | number;
2922
+ maintenance_amount: string | number;
2871
2923
  }>;
2872
2924
  }>;
2873
- liquidation_ioc_buffer: number;
2874
- backstop_liquidation_threshold: number;
2875
- liquidation_fee: number;
2925
+ liquidation_ioc_buffer: string | number;
2926
+ backstop_liquidation_threshold: string | number;
2927
+ liquidation_fee: string | number;
2876
2928
  }>>;
2877
2929
  }, "strip", z.ZodTypeAny, {
2878
2930
  value: {
2879
- perp_leverage_tables: Map<any, {
2880
- tiers: Map<any, {
2931
+ perp_leverage_tables: Map<number, {
2932
+ tiers: Map<string, {
2881
2933
  max_leverage: number;
2882
- mmr: number;
2883
- maintenance_amount: number;
2934
+ mmr: import("decimal.js").Decimal;
2935
+ maintenance_amount: import("decimal.js").Decimal;
2884
2936
  }>;
2885
2937
  }>;
2886
- liquidation_ioc_buffer: number;
2887
- backstop_liquidation_threshold: number;
2888
- 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;
2889
2941
  } | null;
2890
2942
  }, {
2891
2943
  value: {
2892
2944
  perp_leverage_tables: Record<string, {
2893
2945
  tiers: Record<string, {
2894
2946
  max_leverage: number;
2895
- mmr: number;
2896
- maintenance_amount: number;
2947
+ mmr: string | number;
2948
+ maintenance_amount: string | number;
2897
2949
  }>;
2898
2950
  }>;
2899
- liquidation_ioc_buffer: number;
2900
- backstop_liquidation_threshold: number;
2901
- liquidation_fee: number;
2951
+ liquidation_ioc_buffer: string | number;
2952
+ backstop_liquidation_threshold: string | number;
2953
+ liquidation_fee: string | number;
2902
2954
  } | null;
2903
2955
  }>;
2904
- 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>>>;
2905
2957
  }, "strip", z.ZodTypeAny, {
2906
2958
  data: {
2907
2959
  value: {
2908
- perp_leverage_tables: Map<any, {
2909
- tiers: Map<any, {
2960
+ perp_leverage_tables: Map<number, {
2961
+ tiers: Map<string, {
2910
2962
  max_leverage: number;
2911
- mmr: number;
2912
- maintenance_amount: number;
2963
+ mmr: import("decimal.js").Decimal;
2964
+ maintenance_amount: import("decimal.js").Decimal;
2913
2965
  }>;
2914
2966
  }>;
2915
- liquidation_ioc_buffer: number;
2916
- backstop_liquidation_threshold: number;
2917
- 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;
2918
2970
  } | null;
2919
2971
  };
2920
- meta?: Map<any, unknown> | undefined;
2972
+ meta?: Map<unknown, unknown> | undefined;
2921
2973
  }, {
2922
2974
  data: {
2923
2975
  value: {
2924
2976
  perp_leverage_tables: Record<string, {
2925
2977
  tiers: Record<string, {
2926
2978
  max_leverage: number;
2927
- mmr: number;
2928
- maintenance_amount: number;
2979
+ mmr: string | number;
2980
+ maintenance_amount: string | number;
2929
2981
  }>;
2930
2982
  }>;
2931
- liquidation_ioc_buffer: number;
2932
- backstop_liquidation_threshold: number;
2933
- liquidation_fee: number;
2983
+ liquidation_ioc_buffer: string | number;
2984
+ backstop_liquidation_threshold: string | number;
2985
+ liquidation_fee: string | number;
2934
2986
  } | null;
2935
2987
  };
2936
2988
  meta?: Record<string, unknown> | undefined;
@@ -2943,12 +2995,12 @@ export declare const ResponseSchemas: {
2943
2995
  }, {
2944
2996
  accounts: string[];
2945
2997
  }>;
2946
- 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>>>;
2947
2999
  }, "strip", z.ZodTypeAny, {
2948
3000
  data: {
2949
3001
  accounts: string[];
2950
3002
  };
2951
- meta?: Map<any, unknown> | undefined;
3003
+ meta?: Map<unknown, unknown> | undefined;
2952
3004
  }, {
2953
3005
  data: {
2954
3006
  accounts: string[];
@@ -2957,18 +3009,18 @@ export declare const ResponseSchemas: {
2957
3009
  }>;
2958
3010
  readonly Assets: z.ZodObject<{
2959
3011
  data: z.ZodObject<{
2960
- 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>>;
2961
3013
  }, "strip", z.ZodTypeAny, {
2962
- assets: Map<any, string>;
3014
+ assets: Map<number, string>;
2963
3015
  }, {
2964
3016
  assets: Record<string, string>;
2965
3017
  }>;
2966
- 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>>>;
2967
3019
  }, "strip", z.ZodTypeAny, {
2968
3020
  data: {
2969
- assets: Map<any, string>;
3021
+ assets: Map<number, string>;
2970
3022
  };
2971
- meta?: Map<any, unknown> | undefined;
3023
+ meta?: Map<unknown, unknown> | undefined;
2972
3024
  }, {
2973
3025
  data: {
2974
3026
  assets: Record<string, string>;