@emberai/onchain-actions-registry 2.0.0-alpha.4 → 2.0.0-alpha.6

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 (7) hide show
  1. package/dist/index.cjs +6 -6
  2. package/dist/index.cjs.map +1 -1
  3. package/dist/index.d.cts +2793 -211
  4. package/dist/index.d.ts +2793 -211
  5. package/dist/index.js +6 -6
  6. package/dist/index.js.map +1 -1
  7. package/package.json +6 -5
package/dist/index.d.cts CHANGED
@@ -16,88 +16,400 @@ declare const SwapTokensRequestSchema: z.ZodObject<{
16
16
  tokenUid: z.ZodObject<{
17
17
  chainId: z.ZodString;
18
18
  address: z.ZodString;
19
- }, z.core.$strip>;
19
+ }, "strip", z.ZodTypeAny, {
20
+ chainId: string;
21
+ address: string;
22
+ }, {
23
+ chainId: string;
24
+ address: string;
25
+ }>;
20
26
  name: z.ZodString;
21
27
  symbol: z.ZodString;
22
28
  isNative: z.ZodBoolean;
23
29
  decimals: z.ZodNumber;
24
30
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
25
31
  isVetted: z.ZodBoolean;
26
- }, z.core.$strip>;
32
+ }, "strip", z.ZodTypeAny, {
33
+ symbol: string;
34
+ tokenUid: {
35
+ chainId: string;
36
+ address: string;
37
+ };
38
+ name: string;
39
+ isNative: boolean;
40
+ decimals: number;
41
+ isVetted: boolean;
42
+ iconUri?: string | null | undefined;
43
+ }, {
44
+ symbol: string;
45
+ tokenUid: {
46
+ chainId: string;
47
+ address: string;
48
+ };
49
+ name: string;
50
+ isNative: boolean;
51
+ decimals: number;
52
+ isVetted: boolean;
53
+ iconUri?: string | null | undefined;
54
+ }>;
27
55
  toToken: z.ZodObject<{
28
56
  tokenUid: z.ZodObject<{
29
57
  chainId: z.ZodString;
30
58
  address: z.ZodString;
31
- }, z.core.$strip>;
59
+ }, "strip", z.ZodTypeAny, {
60
+ chainId: string;
61
+ address: string;
62
+ }, {
63
+ chainId: string;
64
+ address: string;
65
+ }>;
32
66
  name: z.ZodString;
33
67
  symbol: z.ZodString;
34
68
  isNative: z.ZodBoolean;
35
69
  decimals: z.ZodNumber;
36
70
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
37
71
  isVetted: z.ZodBoolean;
38
- }, z.core.$strip>;
72
+ }, "strip", z.ZodTypeAny, {
73
+ symbol: string;
74
+ tokenUid: {
75
+ chainId: string;
76
+ address: string;
77
+ };
78
+ name: string;
79
+ isNative: boolean;
80
+ decimals: number;
81
+ isVetted: boolean;
82
+ iconUri?: string | null | undefined;
83
+ }, {
84
+ symbol: string;
85
+ tokenUid: {
86
+ chainId: string;
87
+ address: string;
88
+ };
89
+ name: string;
90
+ isNative: boolean;
91
+ decimals: number;
92
+ isVetted: boolean;
93
+ iconUri?: string | null | undefined;
94
+ }>;
39
95
  amount: z.ZodBigInt;
40
96
  limitPrice: z.ZodOptional<z.ZodString>;
41
97
  slippageTolerance: z.ZodOptional<z.ZodString>;
42
98
  expiration: z.ZodOptional<z.ZodString>;
43
99
  recipient: z.ZodString;
44
- }, z.core.$strip>;
100
+ }, "strip", z.ZodTypeAny, {
101
+ fromToken: {
102
+ symbol: string;
103
+ tokenUid: {
104
+ chainId: string;
105
+ address: string;
106
+ };
107
+ name: string;
108
+ isNative: boolean;
109
+ decimals: number;
110
+ isVetted: boolean;
111
+ iconUri?: string | null | undefined;
112
+ };
113
+ toToken: {
114
+ symbol: string;
115
+ tokenUid: {
116
+ chainId: string;
117
+ address: string;
118
+ };
119
+ name: string;
120
+ isNative: boolean;
121
+ decimals: number;
122
+ isVetted: boolean;
123
+ iconUri?: string | null | undefined;
124
+ };
125
+ amount: bigint;
126
+ recipient: string;
127
+ expiration?: string | undefined;
128
+ limitPrice?: string | undefined;
129
+ slippageTolerance?: string | undefined;
130
+ }, {
131
+ fromToken: {
132
+ symbol: string;
133
+ tokenUid: {
134
+ chainId: string;
135
+ address: string;
136
+ };
137
+ name: string;
138
+ isNative: boolean;
139
+ decimals: number;
140
+ isVetted: boolean;
141
+ iconUri?: string | null | undefined;
142
+ };
143
+ toToken: {
144
+ symbol: string;
145
+ tokenUid: {
146
+ chainId: string;
147
+ address: string;
148
+ };
149
+ name: string;
150
+ isNative: boolean;
151
+ decimals: number;
152
+ isVetted: boolean;
153
+ iconUri?: string | null | undefined;
154
+ };
155
+ amount: bigint;
156
+ recipient: string;
157
+ expiration?: string | undefined;
158
+ limitPrice?: string | undefined;
159
+ slippageTolerance?: string | undefined;
160
+ }>;
45
161
  type SwapTokensRequest = z.infer<typeof SwapTokensRequestSchema>;
46
162
  declare const SwapTokensResponseSchema: z.ZodObject<{
47
163
  fromToken: z.ZodObject<{
48
164
  tokenUid: z.ZodObject<{
49
165
  chainId: z.ZodString;
50
166
  address: z.ZodString;
51
- }, z.core.$strip>;
167
+ }, "strip", z.ZodTypeAny, {
168
+ chainId: string;
169
+ address: string;
170
+ }, {
171
+ chainId: string;
172
+ address: string;
173
+ }>;
52
174
  name: z.ZodString;
53
175
  symbol: z.ZodString;
54
176
  isNative: z.ZodBoolean;
55
177
  decimals: z.ZodNumber;
56
178
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
57
179
  isVetted: z.ZodBoolean;
58
- }, z.core.$strip>;
180
+ }, "strip", z.ZodTypeAny, {
181
+ symbol: string;
182
+ tokenUid: {
183
+ chainId: string;
184
+ address: string;
185
+ };
186
+ name: string;
187
+ isNative: boolean;
188
+ decimals: number;
189
+ isVetted: boolean;
190
+ iconUri?: string | null | undefined;
191
+ }, {
192
+ symbol: string;
193
+ tokenUid: {
194
+ chainId: string;
195
+ address: string;
196
+ };
197
+ name: string;
198
+ isNative: boolean;
199
+ decimals: number;
200
+ isVetted: boolean;
201
+ iconUri?: string | null | undefined;
202
+ }>;
59
203
  toToken: z.ZodObject<{
60
204
  tokenUid: z.ZodObject<{
61
205
  chainId: z.ZodString;
62
206
  address: z.ZodString;
63
- }, z.core.$strip>;
207
+ }, "strip", z.ZodTypeAny, {
208
+ chainId: string;
209
+ address: string;
210
+ }, {
211
+ chainId: string;
212
+ address: string;
213
+ }>;
64
214
  name: z.ZodString;
65
215
  symbol: z.ZodString;
66
216
  isNative: z.ZodBoolean;
67
217
  decimals: z.ZodNumber;
68
218
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
69
219
  isVetted: z.ZodBoolean;
70
- }, z.core.$strip>;
220
+ }, "strip", z.ZodTypeAny, {
221
+ symbol: string;
222
+ tokenUid: {
223
+ chainId: string;
224
+ address: string;
225
+ };
226
+ name: string;
227
+ isNative: boolean;
228
+ decimals: number;
229
+ isVetted: boolean;
230
+ iconUri?: string | null | undefined;
231
+ }, {
232
+ symbol: string;
233
+ tokenUid: {
234
+ chainId: string;
235
+ address: string;
236
+ };
237
+ name: string;
238
+ isNative: boolean;
239
+ decimals: number;
240
+ isVetted: boolean;
241
+ iconUri?: string | null | undefined;
242
+ }>;
71
243
  exactFromAmount: z.ZodString;
72
244
  displayFromAmount: z.ZodString;
73
245
  exactToAmount: z.ZodString;
74
246
  displayToAmount: z.ZodString;
75
247
  transactions: z.ZodArray<z.ZodObject<{
76
- type: z.ZodEnum<{
77
- [x: string]: string;
78
- }>;
248
+ type: z.ZodEnum<[string, ...string[]]>;
79
249
  to: z.ZodString;
80
250
  data: z.ZodString;
81
251
  value: z.ZodString;
82
252
  chainId: z.ZodString;
83
- }, z.core.$strip>>;
253
+ }, "strip", z.ZodTypeAny, {
254
+ value: string;
255
+ type: string;
256
+ chainId: string;
257
+ to: string;
258
+ data: string;
259
+ }, {
260
+ value: string;
261
+ type: string;
262
+ chainId: string;
263
+ to: string;
264
+ data: string;
265
+ }>, "many">;
84
266
  feeBreakdown: z.ZodOptional<z.ZodObject<{
85
267
  serviceFee: z.ZodString;
86
268
  slippageCost: z.ZodString;
87
269
  total: z.ZodString;
88
270
  feeDenomination: z.ZodString;
89
- }, z.core.$strip>>;
271
+ }, "strip", z.ZodTypeAny, {
272
+ serviceFee: string;
273
+ slippageCost: string;
274
+ total: string;
275
+ feeDenomination: string;
276
+ }, {
277
+ serviceFee: string;
278
+ slippageCost: string;
279
+ total: string;
280
+ feeDenomination: string;
281
+ }>>;
90
282
  estimation: z.ZodOptional<z.ZodObject<{
91
283
  effectivePrice: z.ZodString;
92
284
  timeEstimate: z.ZodString;
93
285
  expiration: z.ZodString;
94
- }, z.core.$strip>>;
286
+ }, "strip", z.ZodTypeAny, {
287
+ effectivePrice: string;
288
+ timeEstimate: string;
289
+ expiration: string;
290
+ }, {
291
+ effectivePrice: string;
292
+ timeEstimate: string;
293
+ expiration: string;
294
+ }>>;
95
295
  providerTracking: z.ZodOptional<z.ZodObject<{
96
296
  requestId: z.ZodString;
97
297
  providerName: z.ZodString;
98
298
  explorerUrl: z.ZodString;
99
- }, z.core.$strip>>;
100
- }, z.core.$strip>;
299
+ }, "strip", z.ZodTypeAny, {
300
+ requestId: string;
301
+ providerName: string;
302
+ explorerUrl: string;
303
+ }, {
304
+ requestId: string;
305
+ providerName: string;
306
+ explorerUrl: string;
307
+ }>>;
308
+ }, "strip", z.ZodTypeAny, {
309
+ fromToken: {
310
+ symbol: string;
311
+ tokenUid: {
312
+ chainId: string;
313
+ address: string;
314
+ };
315
+ name: string;
316
+ isNative: boolean;
317
+ decimals: number;
318
+ isVetted: boolean;
319
+ iconUri?: string | null | undefined;
320
+ };
321
+ toToken: {
322
+ symbol: string;
323
+ tokenUid: {
324
+ chainId: string;
325
+ address: string;
326
+ };
327
+ name: string;
328
+ isNative: boolean;
329
+ decimals: number;
330
+ isVetted: boolean;
331
+ iconUri?: string | null | undefined;
332
+ };
333
+ exactFromAmount: string;
334
+ displayFromAmount: string;
335
+ exactToAmount: string;
336
+ displayToAmount: string;
337
+ transactions: {
338
+ value: string;
339
+ type: string;
340
+ chainId: string;
341
+ to: string;
342
+ data: string;
343
+ }[];
344
+ feeBreakdown?: {
345
+ serviceFee: string;
346
+ slippageCost: string;
347
+ total: string;
348
+ feeDenomination: string;
349
+ } | undefined;
350
+ estimation?: {
351
+ effectivePrice: string;
352
+ timeEstimate: string;
353
+ expiration: string;
354
+ } | undefined;
355
+ providerTracking?: {
356
+ requestId: string;
357
+ providerName: string;
358
+ explorerUrl: string;
359
+ } | undefined;
360
+ }, {
361
+ fromToken: {
362
+ symbol: string;
363
+ tokenUid: {
364
+ chainId: string;
365
+ address: string;
366
+ };
367
+ name: string;
368
+ isNative: boolean;
369
+ decimals: number;
370
+ isVetted: boolean;
371
+ iconUri?: string | null | undefined;
372
+ };
373
+ toToken: {
374
+ symbol: string;
375
+ tokenUid: {
376
+ chainId: string;
377
+ address: string;
378
+ };
379
+ name: string;
380
+ isNative: boolean;
381
+ decimals: number;
382
+ isVetted: boolean;
383
+ iconUri?: string | null | undefined;
384
+ };
385
+ exactFromAmount: string;
386
+ displayFromAmount: string;
387
+ exactToAmount: string;
388
+ displayToAmount: string;
389
+ transactions: {
390
+ value: string;
391
+ type: string;
392
+ chainId: string;
393
+ to: string;
394
+ data: string;
395
+ }[];
396
+ feeBreakdown?: {
397
+ serviceFee: string;
398
+ slippageCost: string;
399
+ total: string;
400
+ feeDenomination: string;
401
+ } | undefined;
402
+ estimation?: {
403
+ effectivePrice: string;
404
+ timeEstimate: string;
405
+ expiration: string;
406
+ } | undefined;
407
+ providerTracking?: {
408
+ requestId: string;
409
+ providerName: string;
410
+ explorerUrl: string;
411
+ } | undefined;
412
+ }>;
101
413
  type SwapTokensResponse = z.infer<typeof SwapTokensResponseSchema>;
102
414
 
103
415
  /**
@@ -114,17 +426,75 @@ declare const BorrowTokensRequestSchema: z.ZodObject<{
114
426
  tokenUid: z.ZodObject<{
115
427
  chainId: z.ZodString;
116
428
  address: z.ZodString;
117
- }, z.core.$strip>;
429
+ }, "strip", z.ZodTypeAny, {
430
+ chainId: string;
431
+ address: string;
432
+ }, {
433
+ chainId: string;
434
+ address: string;
435
+ }>;
118
436
  name: z.ZodString;
119
437
  symbol: z.ZodString;
120
438
  isNative: z.ZodBoolean;
121
439
  decimals: z.ZodNumber;
122
440
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
123
441
  isVetted: z.ZodBoolean;
124
- }, z.core.$strip>;
442
+ }, "strip", z.ZodTypeAny, {
443
+ symbol: string;
444
+ tokenUid: {
445
+ chainId: string;
446
+ address: string;
447
+ };
448
+ name: string;
449
+ isNative: boolean;
450
+ decimals: number;
451
+ isVetted: boolean;
452
+ iconUri?: string | null | undefined;
453
+ }, {
454
+ symbol: string;
455
+ tokenUid: {
456
+ chainId: string;
457
+ address: string;
458
+ };
459
+ name: string;
460
+ isNative: boolean;
461
+ decimals: number;
462
+ isVetted: boolean;
463
+ iconUri?: string | null | undefined;
464
+ }>;
125
465
  amount: z.ZodBigInt;
126
466
  walletAddress: z.ZodString;
127
- }, z.core.$strip>;
467
+ }, "strip", z.ZodTypeAny, {
468
+ amount: bigint;
469
+ borrowToken: {
470
+ symbol: string;
471
+ tokenUid: {
472
+ chainId: string;
473
+ address: string;
474
+ };
475
+ name: string;
476
+ isNative: boolean;
477
+ decimals: number;
478
+ isVetted: boolean;
479
+ iconUri?: string | null | undefined;
480
+ };
481
+ walletAddress: string;
482
+ }, {
483
+ amount: bigint;
484
+ borrowToken: {
485
+ symbol: string;
486
+ tokenUid: {
487
+ chainId: string;
488
+ address: string;
489
+ };
490
+ name: string;
491
+ isNative: boolean;
492
+ decimals: number;
493
+ isVetted: boolean;
494
+ iconUri?: string | null | undefined;
495
+ };
496
+ walletAddress: string;
497
+ }>;
128
498
  type BorrowTokensRequest = z.infer<typeof BorrowTokensRequestSchema>;
129
499
  declare const BorrowTokensResponseSchema: z.ZodObject<{
130
500
  currentBorrowApy: z.ZodString;
@@ -134,34 +504,144 @@ declare const BorrowTokensResponseSchema: z.ZodObject<{
134
504
  slippageCost: z.ZodString;
135
505
  total: z.ZodString;
136
506
  feeDenomination: z.ZodString;
137
- }, z.core.$strip>>;
507
+ }, "strip", z.ZodTypeAny, {
508
+ serviceFee: string;
509
+ slippageCost: string;
510
+ total: string;
511
+ feeDenomination: string;
512
+ }, {
513
+ serviceFee: string;
514
+ slippageCost: string;
515
+ total: string;
516
+ feeDenomination: string;
517
+ }>>;
138
518
  transactions: z.ZodArray<z.ZodObject<{
139
- type: z.ZodEnum<{
140
- [x: string]: string;
141
- }>;
519
+ type: z.ZodEnum<[string, ...string[]]>;
142
520
  to: z.ZodString;
143
521
  data: z.ZodString;
144
522
  value: z.ZodString;
145
523
  chainId: z.ZodString;
146
- }, z.core.$strip>>;
147
- }, z.core.$strip>;
524
+ }, "strip", z.ZodTypeAny, {
525
+ value: string;
526
+ type: string;
527
+ chainId: string;
528
+ to: string;
529
+ data: string;
530
+ }, {
531
+ value: string;
532
+ type: string;
533
+ chainId: string;
534
+ to: string;
535
+ data: string;
536
+ }>, "many">;
537
+ }, "strip", z.ZodTypeAny, {
538
+ transactions: {
539
+ value: string;
540
+ type: string;
541
+ chainId: string;
542
+ to: string;
543
+ data: string;
544
+ }[];
545
+ currentBorrowApy: string;
546
+ liquidationThreshold: string;
547
+ feeBreakdown?: {
548
+ serviceFee: string;
549
+ slippageCost: string;
550
+ total: string;
551
+ feeDenomination: string;
552
+ } | undefined;
553
+ }, {
554
+ transactions: {
555
+ value: string;
556
+ type: string;
557
+ chainId: string;
558
+ to: string;
559
+ data: string;
560
+ }[];
561
+ currentBorrowApy: string;
562
+ liquidationThreshold: string;
563
+ feeBreakdown?: {
564
+ serviceFee: string;
565
+ slippageCost: string;
566
+ total: string;
567
+ feeDenomination: string;
568
+ } | undefined;
569
+ }>;
148
570
  type BorrowTokensResponse = z.infer<typeof BorrowTokensResponseSchema>;
149
571
  declare const RepayTokensRequestSchema: z.ZodObject<{
150
572
  repayToken: z.ZodObject<{
151
573
  tokenUid: z.ZodObject<{
152
574
  chainId: z.ZodString;
153
575
  address: z.ZodString;
154
- }, z.core.$strip>;
576
+ }, "strip", z.ZodTypeAny, {
577
+ chainId: string;
578
+ address: string;
579
+ }, {
580
+ chainId: string;
581
+ address: string;
582
+ }>;
155
583
  name: z.ZodString;
156
584
  symbol: z.ZodString;
157
585
  isNative: z.ZodBoolean;
158
586
  decimals: z.ZodNumber;
159
587
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
160
588
  isVetted: z.ZodBoolean;
161
- }, z.core.$strip>;
589
+ }, "strip", z.ZodTypeAny, {
590
+ symbol: string;
591
+ tokenUid: {
592
+ chainId: string;
593
+ address: string;
594
+ };
595
+ name: string;
596
+ isNative: boolean;
597
+ decimals: number;
598
+ isVetted: boolean;
599
+ iconUri?: string | null | undefined;
600
+ }, {
601
+ symbol: string;
602
+ tokenUid: {
603
+ chainId: string;
604
+ address: string;
605
+ };
606
+ name: string;
607
+ isNative: boolean;
608
+ decimals: number;
609
+ isVetted: boolean;
610
+ iconUri?: string | null | undefined;
611
+ }>;
162
612
  amount: z.ZodBigInt;
163
613
  walletAddress: z.ZodString;
164
- }, z.core.$strip>;
614
+ }, "strip", z.ZodTypeAny, {
615
+ amount: bigint;
616
+ walletAddress: string;
617
+ repayToken: {
618
+ symbol: string;
619
+ tokenUid: {
620
+ chainId: string;
621
+ address: string;
622
+ };
623
+ name: string;
624
+ isNative: boolean;
625
+ decimals: number;
626
+ isVetted: boolean;
627
+ iconUri?: string | null | undefined;
628
+ };
629
+ }, {
630
+ amount: bigint;
631
+ walletAddress: string;
632
+ repayToken: {
633
+ symbol: string;
634
+ tokenUid: {
635
+ chainId: string;
636
+ address: string;
637
+ };
638
+ name: string;
639
+ isNative: boolean;
640
+ decimals: number;
641
+ isVetted: boolean;
642
+ iconUri?: string | null | undefined;
643
+ };
644
+ }>;
165
645
  type RepayTokensRequest = z.infer<typeof RepayTokensRequestSchema>;
166
646
  declare const RepayTokensResponseSchema: z.ZodObject<{
167
647
  feeBreakdown: z.ZodOptional<z.ZodObject<{
@@ -169,34 +649,140 @@ declare const RepayTokensResponseSchema: z.ZodObject<{
169
649
  slippageCost: z.ZodString;
170
650
  total: z.ZodString;
171
651
  feeDenomination: z.ZodString;
172
- }, z.core.$strip>>;
652
+ }, "strip", z.ZodTypeAny, {
653
+ serviceFee: string;
654
+ slippageCost: string;
655
+ total: string;
656
+ feeDenomination: string;
657
+ }, {
658
+ serviceFee: string;
659
+ slippageCost: string;
660
+ total: string;
661
+ feeDenomination: string;
662
+ }>>;
173
663
  transactions: z.ZodArray<z.ZodObject<{
174
- type: z.ZodEnum<{
175
- [x: string]: string;
176
- }>;
664
+ type: z.ZodEnum<[string, ...string[]]>;
177
665
  to: z.ZodString;
178
666
  data: z.ZodString;
179
667
  value: z.ZodString;
180
668
  chainId: z.ZodString;
181
- }, z.core.$strip>>;
182
- }, z.core.$strip>;
669
+ }, "strip", z.ZodTypeAny, {
670
+ value: string;
671
+ type: string;
672
+ chainId: string;
673
+ to: string;
674
+ data: string;
675
+ }, {
676
+ value: string;
677
+ type: string;
678
+ chainId: string;
679
+ to: string;
680
+ data: string;
681
+ }>, "many">;
682
+ }, "strip", z.ZodTypeAny, {
683
+ transactions: {
684
+ value: string;
685
+ type: string;
686
+ chainId: string;
687
+ to: string;
688
+ data: string;
689
+ }[];
690
+ feeBreakdown?: {
691
+ serviceFee: string;
692
+ slippageCost: string;
693
+ total: string;
694
+ feeDenomination: string;
695
+ } | undefined;
696
+ }, {
697
+ transactions: {
698
+ value: string;
699
+ type: string;
700
+ chainId: string;
701
+ to: string;
702
+ data: string;
703
+ }[];
704
+ feeBreakdown?: {
705
+ serviceFee: string;
706
+ slippageCost: string;
707
+ total: string;
708
+ feeDenomination: string;
709
+ } | undefined;
710
+ }>;
183
711
  type RepayTokensResponse = z.infer<typeof RepayTokensResponseSchema>;
184
712
  declare const SupplyTokensRequestSchema: z.ZodObject<{
185
713
  supplyToken: z.ZodObject<{
186
714
  tokenUid: z.ZodObject<{
187
715
  chainId: z.ZodString;
188
716
  address: z.ZodString;
189
- }, z.core.$strip>;
717
+ }, "strip", z.ZodTypeAny, {
718
+ chainId: string;
719
+ address: string;
720
+ }, {
721
+ chainId: string;
722
+ address: string;
723
+ }>;
190
724
  name: z.ZodString;
191
725
  symbol: z.ZodString;
192
726
  isNative: z.ZodBoolean;
193
727
  decimals: z.ZodNumber;
194
728
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
195
729
  isVetted: z.ZodBoolean;
196
- }, z.core.$strip>;
730
+ }, "strip", z.ZodTypeAny, {
731
+ symbol: string;
732
+ tokenUid: {
733
+ chainId: string;
734
+ address: string;
735
+ };
736
+ name: string;
737
+ isNative: boolean;
738
+ decimals: number;
739
+ isVetted: boolean;
740
+ iconUri?: string | null | undefined;
741
+ }, {
742
+ symbol: string;
743
+ tokenUid: {
744
+ chainId: string;
745
+ address: string;
746
+ };
747
+ name: string;
748
+ isNative: boolean;
749
+ decimals: number;
750
+ isVetted: boolean;
751
+ iconUri?: string | null | undefined;
752
+ }>;
197
753
  amount: z.ZodBigInt;
198
754
  walletAddress: z.ZodString;
199
- }, z.core.$strip>;
755
+ }, "strip", z.ZodTypeAny, {
756
+ amount: bigint;
757
+ walletAddress: string;
758
+ supplyToken: {
759
+ symbol: string;
760
+ tokenUid: {
761
+ chainId: string;
762
+ address: string;
763
+ };
764
+ name: string;
765
+ isNative: boolean;
766
+ decimals: number;
767
+ isVetted: boolean;
768
+ iconUri?: string | null | undefined;
769
+ };
770
+ }, {
771
+ amount: bigint;
772
+ walletAddress: string;
773
+ supplyToken: {
774
+ symbol: string;
775
+ tokenUid: {
776
+ chainId: string;
777
+ address: string;
778
+ };
779
+ name: string;
780
+ isNative: boolean;
781
+ decimals: number;
782
+ isVetted: boolean;
783
+ iconUri?: string | null | undefined;
784
+ };
785
+ }>;
200
786
  type SupplyTokensRequest = z.infer<typeof SupplyTokensRequestSchema>;
201
787
  declare const SupplyTokensResponseSchema: z.ZodObject<{
202
788
  feeBreakdown: z.ZodOptional<z.ZodObject<{
@@ -204,34 +790,140 @@ declare const SupplyTokensResponseSchema: z.ZodObject<{
204
790
  slippageCost: z.ZodString;
205
791
  total: z.ZodString;
206
792
  feeDenomination: z.ZodString;
207
- }, z.core.$strip>>;
793
+ }, "strip", z.ZodTypeAny, {
794
+ serviceFee: string;
795
+ slippageCost: string;
796
+ total: string;
797
+ feeDenomination: string;
798
+ }, {
799
+ serviceFee: string;
800
+ slippageCost: string;
801
+ total: string;
802
+ feeDenomination: string;
803
+ }>>;
208
804
  transactions: z.ZodArray<z.ZodObject<{
209
- type: z.ZodEnum<{
210
- [x: string]: string;
211
- }>;
805
+ type: z.ZodEnum<[string, ...string[]]>;
212
806
  to: z.ZodString;
213
807
  data: z.ZodString;
214
808
  value: z.ZodString;
215
809
  chainId: z.ZodString;
216
- }, z.core.$strip>>;
217
- }, z.core.$strip>;
810
+ }, "strip", z.ZodTypeAny, {
811
+ value: string;
812
+ type: string;
813
+ chainId: string;
814
+ to: string;
815
+ data: string;
816
+ }, {
817
+ value: string;
818
+ type: string;
819
+ chainId: string;
820
+ to: string;
821
+ data: string;
822
+ }>, "many">;
823
+ }, "strip", z.ZodTypeAny, {
824
+ transactions: {
825
+ value: string;
826
+ type: string;
827
+ chainId: string;
828
+ to: string;
829
+ data: string;
830
+ }[];
831
+ feeBreakdown?: {
832
+ serviceFee: string;
833
+ slippageCost: string;
834
+ total: string;
835
+ feeDenomination: string;
836
+ } | undefined;
837
+ }, {
838
+ transactions: {
839
+ value: string;
840
+ type: string;
841
+ chainId: string;
842
+ to: string;
843
+ data: string;
844
+ }[];
845
+ feeBreakdown?: {
846
+ serviceFee: string;
847
+ slippageCost: string;
848
+ total: string;
849
+ feeDenomination: string;
850
+ } | undefined;
851
+ }>;
218
852
  type SupplyTokensResponse = z.infer<typeof SupplyTokensResponseSchema>;
219
853
  declare const WithdrawTokensRequestSchema: z.ZodObject<{
220
854
  tokenToWithdraw: z.ZodObject<{
221
855
  tokenUid: z.ZodObject<{
222
856
  chainId: z.ZodString;
223
857
  address: z.ZodString;
224
- }, z.core.$strip>;
858
+ }, "strip", z.ZodTypeAny, {
859
+ chainId: string;
860
+ address: string;
861
+ }, {
862
+ chainId: string;
863
+ address: string;
864
+ }>;
225
865
  name: z.ZodString;
226
866
  symbol: z.ZodString;
227
867
  isNative: z.ZodBoolean;
228
868
  decimals: z.ZodNumber;
229
869
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
230
870
  isVetted: z.ZodBoolean;
231
- }, z.core.$strip>;
871
+ }, "strip", z.ZodTypeAny, {
872
+ symbol: string;
873
+ tokenUid: {
874
+ chainId: string;
875
+ address: string;
876
+ };
877
+ name: string;
878
+ isNative: boolean;
879
+ decimals: number;
880
+ isVetted: boolean;
881
+ iconUri?: string | null | undefined;
882
+ }, {
883
+ symbol: string;
884
+ tokenUid: {
885
+ chainId: string;
886
+ address: string;
887
+ };
888
+ name: string;
889
+ isNative: boolean;
890
+ decimals: number;
891
+ isVetted: boolean;
892
+ iconUri?: string | null | undefined;
893
+ }>;
232
894
  amount: z.ZodBigInt;
233
895
  walletAddress: z.ZodString;
234
- }, z.core.$strip>;
896
+ }, "strip", z.ZodTypeAny, {
897
+ amount: bigint;
898
+ walletAddress: string;
899
+ tokenToWithdraw: {
900
+ symbol: string;
901
+ tokenUid: {
902
+ chainId: string;
903
+ address: string;
904
+ };
905
+ name: string;
906
+ isNative: boolean;
907
+ decimals: number;
908
+ isVetted: boolean;
909
+ iconUri?: string | null | undefined;
910
+ };
911
+ }, {
912
+ amount: bigint;
913
+ walletAddress: string;
914
+ tokenToWithdraw: {
915
+ symbol: string;
916
+ tokenUid: {
917
+ chainId: string;
918
+ address: string;
919
+ };
920
+ name: string;
921
+ isNative: boolean;
922
+ decimals: number;
923
+ isVetted: boolean;
924
+ iconUri?: string | null | undefined;
925
+ };
926
+ }>;
235
927
  type WithdrawTokensRequest = z.infer<typeof WithdrawTokensRequestSchema>;
236
928
  declare const WithdrawTokensResponseSchema: z.ZodObject<{
237
929
  feeBreakdown: z.ZodOptional<z.ZodObject<{
@@ -239,61 +931,241 @@ declare const WithdrawTokensResponseSchema: z.ZodObject<{
239
931
  slippageCost: z.ZodString;
240
932
  total: z.ZodString;
241
933
  feeDenomination: z.ZodString;
242
- }, z.core.$strip>>;
934
+ }, "strip", z.ZodTypeAny, {
935
+ serviceFee: string;
936
+ slippageCost: string;
937
+ total: string;
938
+ feeDenomination: string;
939
+ }, {
940
+ serviceFee: string;
941
+ slippageCost: string;
942
+ total: string;
943
+ feeDenomination: string;
944
+ }>>;
243
945
  transactions: z.ZodArray<z.ZodObject<{
244
- type: z.ZodEnum<{
245
- [x: string]: string;
246
- }>;
946
+ type: z.ZodEnum<[string, ...string[]]>;
247
947
  to: z.ZodString;
248
948
  data: z.ZodString;
249
949
  value: z.ZodString;
250
950
  chainId: z.ZodString;
251
- }, z.core.$strip>>;
252
- }, z.core.$strip>;
951
+ }, "strip", z.ZodTypeAny, {
952
+ value: string;
953
+ type: string;
954
+ chainId: string;
955
+ to: string;
956
+ data: string;
957
+ }, {
958
+ value: string;
959
+ type: string;
960
+ chainId: string;
961
+ to: string;
962
+ data: string;
963
+ }>, "many">;
964
+ }, "strip", z.ZodTypeAny, {
965
+ transactions: {
966
+ value: string;
967
+ type: string;
968
+ chainId: string;
969
+ to: string;
970
+ data: string;
971
+ }[];
972
+ feeBreakdown?: {
973
+ serviceFee: string;
974
+ slippageCost: string;
975
+ total: string;
976
+ feeDenomination: string;
977
+ } | undefined;
978
+ }, {
979
+ transactions: {
980
+ value: string;
981
+ type: string;
982
+ chainId: string;
983
+ to: string;
984
+ data: string;
985
+ }[];
986
+ feeBreakdown?: {
987
+ serviceFee: string;
988
+ slippageCost: string;
989
+ total: string;
990
+ feeDenomination: string;
991
+ } | undefined;
992
+ }>;
253
993
  type WithdrawTokensResponse = z.infer<typeof WithdrawTokensResponseSchema>;
254
994
  declare const TokenPositionSchema: z.ZodObject<{
255
995
  underlyingToken: z.ZodObject<{
256
996
  tokenUid: z.ZodObject<{
257
997
  chainId: z.ZodString;
258
998
  address: z.ZodString;
259
- }, z.core.$strip>;
999
+ }, "strip", z.ZodTypeAny, {
1000
+ chainId: string;
1001
+ address: string;
1002
+ }, {
1003
+ chainId: string;
1004
+ address: string;
1005
+ }>;
260
1006
  name: z.ZodString;
261
1007
  symbol: z.ZodString;
262
1008
  isNative: z.ZodBoolean;
263
1009
  decimals: z.ZodNumber;
264
1010
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
265
1011
  isVetted: z.ZodBoolean;
266
- }, z.core.$strip>;
1012
+ }, "strip", z.ZodTypeAny, {
1013
+ symbol: string;
1014
+ tokenUid: {
1015
+ chainId: string;
1016
+ address: string;
1017
+ };
1018
+ name: string;
1019
+ isNative: boolean;
1020
+ decimals: number;
1021
+ isVetted: boolean;
1022
+ iconUri?: string | null | undefined;
1023
+ }, {
1024
+ symbol: string;
1025
+ tokenUid: {
1026
+ chainId: string;
1027
+ address: string;
1028
+ };
1029
+ name: string;
1030
+ isNative: boolean;
1031
+ decimals: number;
1032
+ isVetted: boolean;
1033
+ iconUri?: string | null | undefined;
1034
+ }>;
267
1035
  borrowRate: z.ZodString;
268
1036
  supplyBalance: z.ZodString;
269
1037
  borrowBalance: z.ZodString;
270
1038
  valueUsd: z.ZodString;
271
- }, z.core.$strip>;
1039
+ }, "strip", z.ZodTypeAny, {
1040
+ underlyingToken: {
1041
+ symbol: string;
1042
+ tokenUid: {
1043
+ chainId: string;
1044
+ address: string;
1045
+ };
1046
+ name: string;
1047
+ isNative: boolean;
1048
+ decimals: number;
1049
+ isVetted: boolean;
1050
+ iconUri?: string | null | undefined;
1051
+ };
1052
+ borrowRate: string;
1053
+ supplyBalance: string;
1054
+ borrowBalance: string;
1055
+ valueUsd: string;
1056
+ }, {
1057
+ underlyingToken: {
1058
+ symbol: string;
1059
+ tokenUid: {
1060
+ chainId: string;
1061
+ address: string;
1062
+ };
1063
+ name: string;
1064
+ isNative: boolean;
1065
+ decimals: number;
1066
+ isVetted: boolean;
1067
+ iconUri?: string | null | undefined;
1068
+ };
1069
+ borrowRate: string;
1070
+ supplyBalance: string;
1071
+ borrowBalance: string;
1072
+ valueUsd: string;
1073
+ }>;
272
1074
  type TokenPosition = z.infer<typeof TokenPositionSchema>;
273
1075
  declare const GetWalletLendingPositionsRequestSchema: z.ZodObject<{
274
1076
  walletAddress: z.ZodString;
275
- }, z.core.$strip>;
1077
+ }, "strip", z.ZodTypeAny, {
1078
+ walletAddress: string;
1079
+ }, {
1080
+ walletAddress: string;
1081
+ }>;
276
1082
  type GetWalletLendingPositionsRequest = z.infer<typeof GetWalletLendingPositionsRequestSchema>;
277
1083
  declare const LendTokenDetailSchema: z.ZodObject<{
278
1084
  token: z.ZodObject<{
279
1085
  tokenUid: z.ZodObject<{
280
1086
  chainId: z.ZodString;
281
1087
  address: z.ZodString;
282
- }, z.core.$strip>;
1088
+ }, "strip", z.ZodTypeAny, {
1089
+ chainId: string;
1090
+ address: string;
1091
+ }, {
1092
+ chainId: string;
1093
+ address: string;
1094
+ }>;
283
1095
  name: z.ZodString;
284
1096
  symbol: z.ZodString;
285
1097
  isNative: z.ZodBoolean;
286
1098
  decimals: z.ZodNumber;
287
1099
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
288
1100
  isVetted: z.ZodBoolean;
289
- }, z.core.$strip>;
1101
+ }, "strip", z.ZodTypeAny, {
1102
+ symbol: string;
1103
+ tokenUid: {
1104
+ chainId: string;
1105
+ address: string;
1106
+ };
1107
+ name: string;
1108
+ isNative: boolean;
1109
+ decimals: number;
1110
+ isVetted: boolean;
1111
+ iconUri?: string | null | undefined;
1112
+ }, {
1113
+ symbol: string;
1114
+ tokenUid: {
1115
+ chainId: string;
1116
+ address: string;
1117
+ };
1118
+ name: string;
1119
+ isNative: boolean;
1120
+ decimals: number;
1121
+ isVetted: boolean;
1122
+ iconUri?: string | null | undefined;
1123
+ }>;
290
1124
  underlyingBalance: z.ZodString;
291
1125
  underlyingBalanceUsd: z.ZodString;
292
1126
  variableBorrows: z.ZodString;
293
1127
  variableBorrowsUsd: z.ZodString;
294
1128
  totalBorrows: z.ZodString;
295
1129
  totalBorrowsUsd: z.ZodString;
296
- }, z.core.$strip>;
1130
+ }, "strip", z.ZodTypeAny, {
1131
+ token: {
1132
+ symbol: string;
1133
+ tokenUid: {
1134
+ chainId: string;
1135
+ address: string;
1136
+ };
1137
+ name: string;
1138
+ isNative: boolean;
1139
+ decimals: number;
1140
+ isVetted: boolean;
1141
+ iconUri?: string | null | undefined;
1142
+ };
1143
+ underlyingBalance: string;
1144
+ underlyingBalanceUsd: string;
1145
+ variableBorrows: string;
1146
+ variableBorrowsUsd: string;
1147
+ totalBorrows: string;
1148
+ totalBorrowsUsd: string;
1149
+ }, {
1150
+ token: {
1151
+ symbol: string;
1152
+ tokenUid: {
1153
+ chainId: string;
1154
+ address: string;
1155
+ };
1156
+ name: string;
1157
+ isNative: boolean;
1158
+ decimals: number;
1159
+ isVetted: boolean;
1160
+ iconUri?: string | null | undefined;
1161
+ };
1162
+ underlyingBalance: string;
1163
+ underlyingBalanceUsd: string;
1164
+ variableBorrows: string;
1165
+ variableBorrowsUsd: string;
1166
+ totalBorrows: string;
1167
+ totalBorrowsUsd: string;
1168
+ }>;
297
1169
  type LendTokenDetail = z.infer<typeof LendTokenDetailSchema>;
298
1170
  declare const GetWalletLendingPositionsResponseSchema: z.ZodObject<{
299
1171
  userReserves: z.ZodArray<z.ZodObject<{
@@ -301,21 +1173,87 @@ declare const GetWalletLendingPositionsResponseSchema: z.ZodObject<{
301
1173
  tokenUid: z.ZodObject<{
302
1174
  chainId: z.ZodString;
303
1175
  address: z.ZodString;
304
- }, z.core.$strip>;
1176
+ }, "strip", z.ZodTypeAny, {
1177
+ chainId: string;
1178
+ address: string;
1179
+ }, {
1180
+ chainId: string;
1181
+ address: string;
1182
+ }>;
305
1183
  name: z.ZodString;
306
1184
  symbol: z.ZodString;
307
1185
  isNative: z.ZodBoolean;
308
1186
  decimals: z.ZodNumber;
309
1187
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
310
1188
  isVetted: z.ZodBoolean;
311
- }, z.core.$strip>;
1189
+ }, "strip", z.ZodTypeAny, {
1190
+ symbol: string;
1191
+ tokenUid: {
1192
+ chainId: string;
1193
+ address: string;
1194
+ };
1195
+ name: string;
1196
+ isNative: boolean;
1197
+ decimals: number;
1198
+ isVetted: boolean;
1199
+ iconUri?: string | null | undefined;
1200
+ }, {
1201
+ symbol: string;
1202
+ tokenUid: {
1203
+ chainId: string;
1204
+ address: string;
1205
+ };
1206
+ name: string;
1207
+ isNative: boolean;
1208
+ decimals: number;
1209
+ isVetted: boolean;
1210
+ iconUri?: string | null | undefined;
1211
+ }>;
312
1212
  underlyingBalance: z.ZodString;
313
1213
  underlyingBalanceUsd: z.ZodString;
314
1214
  variableBorrows: z.ZodString;
315
1215
  variableBorrowsUsd: z.ZodString;
316
1216
  totalBorrows: z.ZodString;
317
1217
  totalBorrowsUsd: z.ZodString;
318
- }, z.core.$strip>>;
1218
+ }, "strip", z.ZodTypeAny, {
1219
+ token: {
1220
+ symbol: string;
1221
+ tokenUid: {
1222
+ chainId: string;
1223
+ address: string;
1224
+ };
1225
+ name: string;
1226
+ isNative: boolean;
1227
+ decimals: number;
1228
+ isVetted: boolean;
1229
+ iconUri?: string | null | undefined;
1230
+ };
1231
+ underlyingBalance: string;
1232
+ underlyingBalanceUsd: string;
1233
+ variableBorrows: string;
1234
+ variableBorrowsUsd: string;
1235
+ totalBorrows: string;
1236
+ totalBorrowsUsd: string;
1237
+ }, {
1238
+ token: {
1239
+ symbol: string;
1240
+ tokenUid: {
1241
+ chainId: string;
1242
+ address: string;
1243
+ };
1244
+ name: string;
1245
+ isNative: boolean;
1246
+ decimals: number;
1247
+ isVetted: boolean;
1248
+ iconUri?: string | null | undefined;
1249
+ };
1250
+ underlyingBalance: string;
1251
+ underlyingBalanceUsd: string;
1252
+ variableBorrows: string;
1253
+ variableBorrowsUsd: string;
1254
+ totalBorrows: string;
1255
+ totalBorrowsUsd: string;
1256
+ }>, "many">;
319
1257
  totalLiquidityUsd: z.ZodString;
320
1258
  totalCollateralUsd: z.ZodString;
321
1259
  totalBorrowsUsd: z.ZodString;
@@ -324,7 +1262,65 @@ declare const GetWalletLendingPositionsResponseSchema: z.ZodObject<{
324
1262
  currentLoanToValue: z.ZodString;
325
1263
  currentLiquidationThreshold: z.ZodString;
326
1264
  healthFactor: z.ZodString;
327
- }, z.core.$strip>;
1265
+ }, "strip", z.ZodTypeAny, {
1266
+ totalBorrowsUsd: string;
1267
+ userReserves: {
1268
+ token: {
1269
+ symbol: string;
1270
+ tokenUid: {
1271
+ chainId: string;
1272
+ address: string;
1273
+ };
1274
+ name: string;
1275
+ isNative: boolean;
1276
+ decimals: number;
1277
+ isVetted: boolean;
1278
+ iconUri?: string | null | undefined;
1279
+ };
1280
+ underlyingBalance: string;
1281
+ underlyingBalanceUsd: string;
1282
+ variableBorrows: string;
1283
+ variableBorrowsUsd: string;
1284
+ totalBorrows: string;
1285
+ totalBorrowsUsd: string;
1286
+ }[];
1287
+ totalLiquidityUsd: string;
1288
+ totalCollateralUsd: string;
1289
+ netWorthUsd: string;
1290
+ availableBorrowsUsd: string;
1291
+ currentLoanToValue: string;
1292
+ currentLiquidationThreshold: string;
1293
+ healthFactor: string;
1294
+ }, {
1295
+ totalBorrowsUsd: string;
1296
+ userReserves: {
1297
+ token: {
1298
+ symbol: string;
1299
+ tokenUid: {
1300
+ chainId: string;
1301
+ address: string;
1302
+ };
1303
+ name: string;
1304
+ isNative: boolean;
1305
+ decimals: number;
1306
+ isVetted: boolean;
1307
+ iconUri?: string | null | undefined;
1308
+ };
1309
+ underlyingBalance: string;
1310
+ underlyingBalanceUsd: string;
1311
+ variableBorrows: string;
1312
+ variableBorrowsUsd: string;
1313
+ totalBorrows: string;
1314
+ totalBorrowsUsd: string;
1315
+ }[];
1316
+ totalLiquidityUsd: string;
1317
+ totalCollateralUsd: string;
1318
+ netWorthUsd: string;
1319
+ availableBorrowsUsd: string;
1320
+ currentLoanToValue: string;
1321
+ currentLiquidationThreshold: string;
1322
+ healthFactor: string;
1323
+ }>;
328
1324
  type GetWalletLendingPositionsResponse = z.infer<typeof GetWalletLendingPositionsResponseSchema>;
329
1325
 
330
1326
  /**
@@ -351,182 +1347,928 @@ type LendingActions = 'lending-borrow' | 'lending-repay' | 'lending-supply' | 'l
351
1347
  declare const LimitedLiquidityProvisionRangeSchema: z.ZodObject<{
352
1348
  minPrice: z.ZodString;
353
1349
  maxPrice: z.ZodString;
354
- }, z.core.$strip>;
1350
+ }, "strip", z.ZodTypeAny, {
1351
+ minPrice: string;
1352
+ maxPrice: string;
1353
+ }, {
1354
+ minPrice: string;
1355
+ maxPrice: string;
1356
+ }>;
355
1357
  type LimitedLiquidityProvisionRange = z.infer<typeof LimitedLiquidityProvisionRangeSchema>;
356
- declare const LiquidityProvisionRangeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
1358
+ declare const LiquidityProvisionRangeSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
357
1359
  type: z.ZodLiteral<"full">;
358
- }, z.core.$strip>, z.ZodObject<{
1360
+ }, "strip", z.ZodTypeAny, {
1361
+ type: "full";
1362
+ }, {
1363
+ type: "full";
1364
+ }>, z.ZodObject<{
359
1365
  type: z.ZodLiteral<"limited">;
360
1366
  minPrice: z.ZodString;
361
1367
  maxPrice: z.ZodString;
362
- }, z.core.$strip>], "type">;
1368
+ }, "strip", z.ZodTypeAny, {
1369
+ type: "limited";
1370
+ minPrice: string;
1371
+ maxPrice: string;
1372
+ }, {
1373
+ type: "limited";
1374
+ minPrice: string;
1375
+ maxPrice: string;
1376
+ }>]>;
363
1377
  type LiquidityProvisionRange = z.infer<typeof LiquidityProvisionRangeSchema>;
364
1378
  declare const LiquidityPositionRangeSchema: z.ZodObject<{
365
1379
  fromPrice: z.ZodString;
366
1380
  toPrice: z.ZodString;
367
- }, z.core.$strip>;
1381
+ }, "strip", z.ZodTypeAny, {
1382
+ fromPrice: string;
1383
+ toPrice: string;
1384
+ }, {
1385
+ fromPrice: string;
1386
+ toPrice: string;
1387
+ }>;
368
1388
  type LiquidityPositionRange = z.infer<typeof LiquidityPositionRangeSchema>;
369
- declare const LiquidityPayTokensSchema: z.ZodObject<{
370
- tokenUid: z.ZodObject<{
371
- chainId: z.ZodString;
372
- address: z.ZodString;
373
- }, z.core.$strip>;
374
- supplyAmount: z.ZodBigInt;
375
- }, z.core.$strip>;
376
- type LiquidityPayTokens = z.infer<typeof LiquidityPayTokensSchema>;
377
1389
  declare const LiquiditySuppliedTokenSchema: z.ZodObject<{
378
1390
  tokenUid: z.ZodObject<{
379
1391
  chainId: z.ZodString;
380
1392
  address: z.ZodString;
381
- }, z.core.$strip>;
1393
+ }, "strip", z.ZodTypeAny, {
1394
+ chainId: string;
1395
+ address: string;
1396
+ }, {
1397
+ chainId: string;
1398
+ address: string;
1399
+ }>;
382
1400
  suppliedAmount: z.ZodString;
383
1401
  owedTokens: z.ZodString;
384
- }, z.core.$strip>;
1402
+ }, "strip", z.ZodTypeAny, {
1403
+ tokenUid: {
1404
+ chainId: string;
1405
+ address: string;
1406
+ };
1407
+ suppliedAmount: string;
1408
+ owedTokens: string;
1409
+ }, {
1410
+ tokenUid: {
1411
+ chainId: string;
1412
+ address: string;
1413
+ };
1414
+ suppliedAmount: string;
1415
+ owedTokens: string;
1416
+ }>;
385
1417
  type LiquiditySuppliedToken = z.infer<typeof LiquiditySuppliedTokenSchema>;
386
1418
  declare const LiquidityPositionSchema: z.ZodObject<{
387
1419
  poolIdentifier: z.ZodObject<{
388
1420
  chainId: z.ZodString;
389
1421
  address: z.ZodString;
390
- }, z.core.$strip>;
1422
+ }, "strip", z.ZodTypeAny, {
1423
+ chainId: string;
1424
+ address: string;
1425
+ }, {
1426
+ chainId: string;
1427
+ address: string;
1428
+ }>;
391
1429
  operator: z.ZodString;
392
1430
  suppliedTokens: z.ZodArray<z.ZodObject<{
393
1431
  tokenUid: z.ZodObject<{
394
1432
  chainId: z.ZodString;
395
1433
  address: z.ZodString;
396
- }, z.core.$strip>;
1434
+ }, "strip", z.ZodTypeAny, {
1435
+ chainId: string;
1436
+ address: string;
1437
+ }, {
1438
+ chainId: string;
1439
+ address: string;
1440
+ }>;
397
1441
  suppliedAmount: z.ZodString;
398
1442
  owedTokens: z.ZodString;
399
- }, z.core.$strip>>;
1443
+ }, "strip", z.ZodTypeAny, {
1444
+ tokenUid: {
1445
+ chainId: string;
1446
+ address: string;
1447
+ };
1448
+ suppliedAmount: string;
1449
+ owedTokens: string;
1450
+ }, {
1451
+ tokenUid: {
1452
+ chainId: string;
1453
+ address: string;
1454
+ };
1455
+ suppliedAmount: string;
1456
+ owedTokens: string;
1457
+ }>, "many">;
400
1458
  price: z.ZodString;
401
1459
  providerId: z.ZodString;
402
1460
  positionRange: z.ZodOptional<z.ZodObject<{
403
1461
  fromPrice: z.ZodString;
404
1462
  toPrice: z.ZodString;
405
- }, z.core.$strip>>;
406
- }, z.core.$strip>;
1463
+ }, "strip", z.ZodTypeAny, {
1464
+ fromPrice: string;
1465
+ toPrice: string;
1466
+ }, {
1467
+ fromPrice: string;
1468
+ toPrice: string;
1469
+ }>>;
1470
+ }, "strip", z.ZodTypeAny, {
1471
+ poolIdentifier: {
1472
+ chainId: string;
1473
+ address: string;
1474
+ };
1475
+ operator: string;
1476
+ suppliedTokens: {
1477
+ tokenUid: {
1478
+ chainId: string;
1479
+ address: string;
1480
+ };
1481
+ suppliedAmount: string;
1482
+ owedTokens: string;
1483
+ }[];
1484
+ price: string;
1485
+ providerId: string;
1486
+ positionRange?: {
1487
+ fromPrice: string;
1488
+ toPrice: string;
1489
+ } | undefined;
1490
+ }, {
1491
+ poolIdentifier: {
1492
+ chainId: string;
1493
+ address: string;
1494
+ };
1495
+ operator: string;
1496
+ suppliedTokens: {
1497
+ tokenUid: {
1498
+ chainId: string;
1499
+ address: string;
1500
+ };
1501
+ suppliedAmount: string;
1502
+ owedTokens: string;
1503
+ }[];
1504
+ price: string;
1505
+ providerId: string;
1506
+ positionRange?: {
1507
+ fromPrice: string;
1508
+ toPrice: string;
1509
+ } | undefined;
1510
+ }>;
407
1511
  type LiquidityPosition = z.infer<typeof LiquidityPositionSchema>;
408
1512
  declare const LiquidityPoolTokens: z.ZodObject<{
409
1513
  tokenUid: z.ZodObject<{
410
1514
  chainId: z.ZodString;
411
1515
  address: z.ZodString;
412
- }, z.core.$strip>;
413
- }, z.core.$strip>;
1516
+ }, "strip", z.ZodTypeAny, {
1517
+ chainId: string;
1518
+ address: string;
1519
+ }, {
1520
+ chainId: string;
1521
+ address: string;
1522
+ }>;
1523
+ }, "strip", z.ZodTypeAny, {
1524
+ tokenUid: {
1525
+ chainId: string;
1526
+ address: string;
1527
+ };
1528
+ }, {
1529
+ tokenUid: {
1530
+ chainId: string;
1531
+ address: string;
1532
+ };
1533
+ }>;
414
1534
  type LiquidityPoolTokens = z.infer<typeof LiquidityPoolTokens>;
415
1535
  declare const LiquidityPoolSchema: z.ZodObject<{
416
1536
  identifier: z.ZodObject<{
417
1537
  chainId: z.ZodString;
418
1538
  address: z.ZodString;
419
- }, z.core.$strip>;
1539
+ }, "strip", z.ZodTypeAny, {
1540
+ chainId: string;
1541
+ address: string;
1542
+ }, {
1543
+ chainId: string;
1544
+ address: string;
1545
+ }>;
420
1546
  tokens: z.ZodArray<z.ZodObject<{
421
1547
  tokenUid: z.ZodObject<{
422
1548
  chainId: z.ZodString;
423
1549
  address: z.ZodString;
424
- }, z.core.$strip>;
425
- }, z.core.$strip>>;
1550
+ }, "strip", z.ZodTypeAny, {
1551
+ chainId: string;
1552
+ address: string;
1553
+ }, {
1554
+ chainId: string;
1555
+ address: string;
1556
+ }>;
1557
+ }, "strip", z.ZodTypeAny, {
1558
+ tokenUid: {
1559
+ chainId: string;
1560
+ address: string;
1561
+ };
1562
+ }, {
1563
+ tokenUid: {
1564
+ chainId: string;
1565
+ address: string;
1566
+ };
1567
+ }>, "many">;
426
1568
  price: z.ZodString;
427
1569
  providerId: z.ZodString;
428
- }, z.core.$strip>;
1570
+ }, "strip", z.ZodTypeAny, {
1571
+ price: string;
1572
+ providerId: string;
1573
+ identifier: {
1574
+ chainId: string;
1575
+ address: string;
1576
+ };
1577
+ tokens: {
1578
+ tokenUid: {
1579
+ chainId: string;
1580
+ address: string;
1581
+ };
1582
+ }[];
1583
+ }, {
1584
+ price: string;
1585
+ providerId: string;
1586
+ identifier: {
1587
+ chainId: string;
1588
+ address: string;
1589
+ };
1590
+ tokens: {
1591
+ tokenUid: {
1592
+ chainId: string;
1593
+ address: string;
1594
+ };
1595
+ }[];
1596
+ }>;
429
1597
  type LiquidityPool = z.infer<typeof LiquidityPoolSchema>;
1598
+ declare const LiquidityPayTokensSchema: z.ZodObject<{
1599
+ token: z.ZodObject<{
1600
+ tokenUid: z.ZodObject<{
1601
+ chainId: z.ZodString;
1602
+ address: z.ZodString;
1603
+ }, "strip", z.ZodTypeAny, {
1604
+ chainId: string;
1605
+ address: string;
1606
+ }, {
1607
+ chainId: string;
1608
+ address: string;
1609
+ }>;
1610
+ name: z.ZodString;
1611
+ symbol: z.ZodString;
1612
+ isNative: z.ZodBoolean;
1613
+ decimals: z.ZodNumber;
1614
+ iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
1615
+ isVetted: z.ZodBoolean;
1616
+ }, "strip", z.ZodTypeAny, {
1617
+ symbol: string;
1618
+ tokenUid: {
1619
+ chainId: string;
1620
+ address: string;
1621
+ };
1622
+ name: string;
1623
+ isNative: boolean;
1624
+ decimals: number;
1625
+ isVetted: boolean;
1626
+ iconUri?: string | null | undefined;
1627
+ }, {
1628
+ symbol: string;
1629
+ tokenUid: {
1630
+ chainId: string;
1631
+ address: string;
1632
+ };
1633
+ name: string;
1634
+ isNative: boolean;
1635
+ decimals: number;
1636
+ isVetted: boolean;
1637
+ iconUri?: string | null | undefined;
1638
+ }>;
1639
+ supplyAmount: z.ZodBigInt;
1640
+ }, "strip", z.ZodTypeAny, {
1641
+ token: {
1642
+ symbol: string;
1643
+ tokenUid: {
1644
+ chainId: string;
1645
+ address: string;
1646
+ };
1647
+ name: string;
1648
+ isNative: boolean;
1649
+ decimals: number;
1650
+ isVetted: boolean;
1651
+ iconUri?: string | null | undefined;
1652
+ };
1653
+ supplyAmount: bigint;
1654
+ }, {
1655
+ token: {
1656
+ symbol: string;
1657
+ tokenUid: {
1658
+ chainId: string;
1659
+ address: string;
1660
+ };
1661
+ name: string;
1662
+ isNative: boolean;
1663
+ decimals: number;
1664
+ isVetted: boolean;
1665
+ iconUri?: string | null | undefined;
1666
+ };
1667
+ supplyAmount: bigint;
1668
+ }>;
1669
+ type LiquidityPayTokens = z.infer<typeof LiquidityPayTokensSchema>;
430
1670
  declare const SupplyLiquidityRequestSchema: z.ZodObject<{
431
1671
  walletAddress: z.ZodString;
432
- poolIdentifier: z.ZodObject<{
433
- chainId: z.ZodString;
434
- address: z.ZodString;
435
- }, z.core.$strip>;
436
- payTokens: z.ZodArray<z.ZodObject<{
1672
+ poolToken: z.ZodObject<{
437
1673
  tokenUid: z.ZodObject<{
438
1674
  chainId: z.ZodString;
439
1675
  address: z.ZodString;
440
- }, z.core.$strip>;
1676
+ }, "strip", z.ZodTypeAny, {
1677
+ chainId: string;
1678
+ address: string;
1679
+ }, {
1680
+ chainId: string;
1681
+ address: string;
1682
+ }>;
1683
+ name: z.ZodString;
1684
+ symbol: z.ZodString;
1685
+ isNative: z.ZodBoolean;
1686
+ decimals: z.ZodNumber;
1687
+ iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
1688
+ isVetted: z.ZodBoolean;
1689
+ }, "strip", z.ZodTypeAny, {
1690
+ symbol: string;
1691
+ tokenUid: {
1692
+ chainId: string;
1693
+ address: string;
1694
+ };
1695
+ name: string;
1696
+ isNative: boolean;
1697
+ decimals: number;
1698
+ isVetted: boolean;
1699
+ iconUri?: string | null | undefined;
1700
+ }, {
1701
+ symbol: string;
1702
+ tokenUid: {
1703
+ chainId: string;
1704
+ address: string;
1705
+ };
1706
+ name: string;
1707
+ isNative: boolean;
1708
+ decimals: number;
1709
+ isVetted: boolean;
1710
+ iconUri?: string | null | undefined;
1711
+ }>;
1712
+ payTokens: z.ZodArray<z.ZodObject<{
1713
+ token: z.ZodObject<{
1714
+ tokenUid: z.ZodObject<{
1715
+ chainId: z.ZodString;
1716
+ address: z.ZodString;
1717
+ }, "strip", z.ZodTypeAny, {
1718
+ chainId: string;
1719
+ address: string;
1720
+ }, {
1721
+ chainId: string;
1722
+ address: string;
1723
+ }>;
1724
+ name: z.ZodString;
1725
+ symbol: z.ZodString;
1726
+ isNative: z.ZodBoolean;
1727
+ decimals: z.ZodNumber;
1728
+ iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
1729
+ isVetted: z.ZodBoolean;
1730
+ }, "strip", z.ZodTypeAny, {
1731
+ symbol: string;
1732
+ tokenUid: {
1733
+ chainId: string;
1734
+ address: string;
1735
+ };
1736
+ name: string;
1737
+ isNative: boolean;
1738
+ decimals: number;
1739
+ isVetted: boolean;
1740
+ iconUri?: string | null | undefined;
1741
+ }, {
1742
+ symbol: string;
1743
+ tokenUid: {
1744
+ chainId: string;
1745
+ address: string;
1746
+ };
1747
+ name: string;
1748
+ isNative: boolean;
1749
+ decimals: number;
1750
+ isVetted: boolean;
1751
+ iconUri?: string | null | undefined;
1752
+ }>;
441
1753
  supplyAmount: z.ZodBigInt;
442
- }, z.core.$strip>>;
443
- range: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
1754
+ }, "strip", z.ZodTypeAny, {
1755
+ token: {
1756
+ symbol: string;
1757
+ tokenUid: {
1758
+ chainId: string;
1759
+ address: string;
1760
+ };
1761
+ name: string;
1762
+ isNative: boolean;
1763
+ decimals: number;
1764
+ isVetted: boolean;
1765
+ iconUri?: string | null | undefined;
1766
+ };
1767
+ supplyAmount: bigint;
1768
+ }, {
1769
+ token: {
1770
+ symbol: string;
1771
+ tokenUid: {
1772
+ chainId: string;
1773
+ address: string;
1774
+ };
1775
+ name: string;
1776
+ isNative: boolean;
1777
+ decimals: number;
1778
+ isVetted: boolean;
1779
+ iconUri?: string | null | undefined;
1780
+ };
1781
+ supplyAmount: bigint;
1782
+ }>, "many">;
1783
+ range: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
444
1784
  type: z.ZodLiteral<"full">;
445
- }, z.core.$strip>, z.ZodObject<{
1785
+ }, "strip", z.ZodTypeAny, {
1786
+ type: "full";
1787
+ }, {
1788
+ type: "full";
1789
+ }>, z.ZodObject<{
446
1790
  type: z.ZodLiteral<"limited">;
447
1791
  minPrice: z.ZodString;
448
1792
  maxPrice: z.ZodString;
449
- }, z.core.$strip>], "type">>;
450
- }, z.core.$strip>;
1793
+ }, "strip", z.ZodTypeAny, {
1794
+ type: "limited";
1795
+ minPrice: string;
1796
+ maxPrice: string;
1797
+ }, {
1798
+ type: "limited";
1799
+ minPrice: string;
1800
+ maxPrice: string;
1801
+ }>]>>;
1802
+ }, "strip", z.ZodTypeAny, {
1803
+ walletAddress: string;
1804
+ poolToken: {
1805
+ symbol: string;
1806
+ tokenUid: {
1807
+ chainId: string;
1808
+ address: string;
1809
+ };
1810
+ name: string;
1811
+ isNative: boolean;
1812
+ decimals: number;
1813
+ isVetted: boolean;
1814
+ iconUri?: string | null | undefined;
1815
+ };
1816
+ payTokens: {
1817
+ token: {
1818
+ symbol: string;
1819
+ tokenUid: {
1820
+ chainId: string;
1821
+ address: string;
1822
+ };
1823
+ name: string;
1824
+ isNative: boolean;
1825
+ decimals: number;
1826
+ isVetted: boolean;
1827
+ iconUri?: string | null | undefined;
1828
+ };
1829
+ supplyAmount: bigint;
1830
+ }[];
1831
+ range?: {
1832
+ type: "full";
1833
+ } | {
1834
+ type: "limited";
1835
+ minPrice: string;
1836
+ maxPrice: string;
1837
+ } | undefined;
1838
+ }, {
1839
+ walletAddress: string;
1840
+ poolToken: {
1841
+ symbol: string;
1842
+ tokenUid: {
1843
+ chainId: string;
1844
+ address: string;
1845
+ };
1846
+ name: string;
1847
+ isNative: boolean;
1848
+ decimals: number;
1849
+ isVetted: boolean;
1850
+ iconUri?: string | null | undefined;
1851
+ };
1852
+ payTokens: {
1853
+ token: {
1854
+ symbol: string;
1855
+ tokenUid: {
1856
+ chainId: string;
1857
+ address: string;
1858
+ };
1859
+ name: string;
1860
+ isNative: boolean;
1861
+ decimals: number;
1862
+ isVetted: boolean;
1863
+ iconUri?: string | null | undefined;
1864
+ };
1865
+ supplyAmount: bigint;
1866
+ }[];
1867
+ range?: {
1868
+ type: "full";
1869
+ } | {
1870
+ type: "limited";
1871
+ minPrice: string;
1872
+ maxPrice: string;
1873
+ } | undefined;
1874
+ }>;
451
1875
  type SupplyLiquidityRequest = z.infer<typeof SupplyLiquidityRequestSchema>;
452
1876
  declare const SupplyLiquidityResponseSchema: z.ZodObject<{
453
1877
  transactions: z.ZodArray<z.ZodObject<{
454
- type: z.ZodEnum<{
455
- [x: string]: string;
456
- }>;
1878
+ type: z.ZodEnum<[string, ...string[]]>;
457
1879
  to: z.ZodString;
458
1880
  data: z.ZodString;
459
1881
  value: z.ZodString;
460
1882
  chainId: z.ZodString;
461
- }, z.core.$strip>>;
1883
+ }, "strip", z.ZodTypeAny, {
1884
+ value: string;
1885
+ type: string;
1886
+ chainId: string;
1887
+ to: string;
1888
+ data: string;
1889
+ }, {
1890
+ value: string;
1891
+ type: string;
1892
+ chainId: string;
1893
+ to: string;
1894
+ data: string;
1895
+ }>, "many">;
462
1896
  chainId: z.ZodString;
463
- }, z.core.$strip>;
1897
+ }, "strip", z.ZodTypeAny, {
1898
+ chainId: string;
1899
+ transactions: {
1900
+ value: string;
1901
+ type: string;
1902
+ chainId: string;
1903
+ to: string;
1904
+ data: string;
1905
+ }[];
1906
+ }, {
1907
+ chainId: string;
1908
+ transactions: {
1909
+ value: string;
1910
+ type: string;
1911
+ chainId: string;
1912
+ to: string;
1913
+ data: string;
1914
+ }[];
1915
+ }>;
464
1916
  type SupplyLiquidityResponse = z.infer<typeof SupplyLiquidityResponseSchema>;
465
1917
  declare const WithdrawLiquidityRequestSchema: z.ZodObject<{
466
- poolTokenIdentifier: z.ZodObject<{
467
- chainId: z.ZodString;
468
- address: z.ZodString;
469
- }, z.core.$strip>;
1918
+ poolToken: z.ZodObject<{
1919
+ tokenUid: z.ZodObject<{
1920
+ chainId: z.ZodString;
1921
+ address: z.ZodString;
1922
+ }, "strip", z.ZodTypeAny, {
1923
+ chainId: string;
1924
+ address: string;
1925
+ }, {
1926
+ chainId: string;
1927
+ address: string;
1928
+ }>;
1929
+ name: z.ZodString;
1930
+ symbol: z.ZodString;
1931
+ isNative: z.ZodBoolean;
1932
+ decimals: z.ZodNumber;
1933
+ iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
1934
+ isVetted: z.ZodBoolean;
1935
+ }, "strip", z.ZodTypeAny, {
1936
+ symbol: string;
1937
+ tokenUid: {
1938
+ chainId: string;
1939
+ address: string;
1940
+ };
1941
+ name: string;
1942
+ isNative: boolean;
1943
+ decimals: number;
1944
+ isVetted: boolean;
1945
+ iconUri?: string | null | undefined;
1946
+ }, {
1947
+ symbol: string;
1948
+ tokenUid: {
1949
+ chainId: string;
1950
+ address: string;
1951
+ };
1952
+ name: string;
1953
+ isNative: boolean;
1954
+ decimals: number;
1955
+ isVetted: boolean;
1956
+ iconUri?: string | null | undefined;
1957
+ }>;
470
1958
  walletAddress: z.ZodString;
471
- }, z.core.$strip>;
1959
+ }, "strip", z.ZodTypeAny, {
1960
+ walletAddress: string;
1961
+ poolToken: {
1962
+ symbol: string;
1963
+ tokenUid: {
1964
+ chainId: string;
1965
+ address: string;
1966
+ };
1967
+ name: string;
1968
+ isNative: boolean;
1969
+ decimals: number;
1970
+ isVetted: boolean;
1971
+ iconUri?: string | null | undefined;
1972
+ };
1973
+ }, {
1974
+ walletAddress: string;
1975
+ poolToken: {
1976
+ symbol: string;
1977
+ tokenUid: {
1978
+ chainId: string;
1979
+ address: string;
1980
+ };
1981
+ name: string;
1982
+ isNative: boolean;
1983
+ decimals: number;
1984
+ isVetted: boolean;
1985
+ iconUri?: string | null | undefined;
1986
+ };
1987
+ }>;
472
1988
  type WithdrawLiquidityRequest = z.infer<typeof WithdrawLiquidityRequestSchema>;
473
1989
  declare const WithdrawLiquidityResponseSchema: z.ZodObject<{
474
1990
  transactions: z.ZodArray<z.ZodObject<{
475
- type: z.ZodEnum<{
476
- [x: string]: string;
477
- }>;
1991
+ type: z.ZodEnum<[string, ...string[]]>;
478
1992
  to: z.ZodString;
479
1993
  data: z.ZodString;
480
1994
  value: z.ZodString;
481
1995
  chainId: z.ZodString;
482
- }, z.core.$strip>>;
1996
+ }, "strip", z.ZodTypeAny, {
1997
+ value: string;
1998
+ type: string;
1999
+ chainId: string;
2000
+ to: string;
2001
+ data: string;
2002
+ }, {
2003
+ value: string;
2004
+ type: string;
2005
+ chainId: string;
2006
+ to: string;
2007
+ data: string;
2008
+ }>, "many">;
483
2009
  chainId: z.ZodString;
484
- }, z.core.$strip>;
2010
+ }, "strip", z.ZodTypeAny, {
2011
+ chainId: string;
2012
+ transactions: {
2013
+ value: string;
2014
+ type: string;
2015
+ chainId: string;
2016
+ to: string;
2017
+ data: string;
2018
+ }[];
2019
+ }, {
2020
+ chainId: string;
2021
+ transactions: {
2022
+ value: string;
2023
+ type: string;
2024
+ chainId: string;
2025
+ to: string;
2026
+ data: string;
2027
+ }[];
2028
+ }>;
485
2029
  type WithdrawLiquidityResponse = z.infer<typeof WithdrawLiquidityResponseSchema>;
486
2030
  declare const GetWalletLiquidityPositionsRequestSchema: z.ZodObject<{
487
2031
  walletAddress: z.ZodString;
488
- }, z.core.$strip>;
2032
+ }, "strip", z.ZodTypeAny, {
2033
+ walletAddress: string;
2034
+ }, {
2035
+ walletAddress: string;
2036
+ }>;
489
2037
  type GetWalletLiquidityPositionsRequest = z.infer<typeof GetWalletLiquidityPositionsRequestSchema>;
490
2038
  declare const GetWalletLiquidityPositionsResponseSchema: z.ZodObject<{
491
2039
  positions: z.ZodArray<z.ZodObject<{
492
2040
  poolIdentifier: z.ZodObject<{
493
2041
  chainId: z.ZodString;
494
2042
  address: z.ZodString;
495
- }, z.core.$strip>;
2043
+ }, "strip", z.ZodTypeAny, {
2044
+ chainId: string;
2045
+ address: string;
2046
+ }, {
2047
+ chainId: string;
2048
+ address: string;
2049
+ }>;
496
2050
  operator: z.ZodString;
497
2051
  suppliedTokens: z.ZodArray<z.ZodObject<{
498
2052
  tokenUid: z.ZodObject<{
499
2053
  chainId: z.ZodString;
500
2054
  address: z.ZodString;
501
- }, z.core.$strip>;
2055
+ }, "strip", z.ZodTypeAny, {
2056
+ chainId: string;
2057
+ address: string;
2058
+ }, {
2059
+ chainId: string;
2060
+ address: string;
2061
+ }>;
502
2062
  suppliedAmount: z.ZodString;
503
2063
  owedTokens: z.ZodString;
504
- }, z.core.$strip>>;
2064
+ }, "strip", z.ZodTypeAny, {
2065
+ tokenUid: {
2066
+ chainId: string;
2067
+ address: string;
2068
+ };
2069
+ suppliedAmount: string;
2070
+ owedTokens: string;
2071
+ }, {
2072
+ tokenUid: {
2073
+ chainId: string;
2074
+ address: string;
2075
+ };
2076
+ suppliedAmount: string;
2077
+ owedTokens: string;
2078
+ }>, "many">;
505
2079
  price: z.ZodString;
506
2080
  providerId: z.ZodString;
507
2081
  positionRange: z.ZodOptional<z.ZodObject<{
508
2082
  fromPrice: z.ZodString;
509
2083
  toPrice: z.ZodString;
510
- }, z.core.$strip>>;
511
- }, z.core.$strip>>;
512
- }, z.core.$strip>;
2084
+ }, "strip", z.ZodTypeAny, {
2085
+ fromPrice: string;
2086
+ toPrice: string;
2087
+ }, {
2088
+ fromPrice: string;
2089
+ toPrice: string;
2090
+ }>>;
2091
+ }, "strip", z.ZodTypeAny, {
2092
+ poolIdentifier: {
2093
+ chainId: string;
2094
+ address: string;
2095
+ };
2096
+ operator: string;
2097
+ suppliedTokens: {
2098
+ tokenUid: {
2099
+ chainId: string;
2100
+ address: string;
2101
+ };
2102
+ suppliedAmount: string;
2103
+ owedTokens: string;
2104
+ }[];
2105
+ price: string;
2106
+ providerId: string;
2107
+ positionRange?: {
2108
+ fromPrice: string;
2109
+ toPrice: string;
2110
+ } | undefined;
2111
+ }, {
2112
+ poolIdentifier: {
2113
+ chainId: string;
2114
+ address: string;
2115
+ };
2116
+ operator: string;
2117
+ suppliedTokens: {
2118
+ tokenUid: {
2119
+ chainId: string;
2120
+ address: string;
2121
+ };
2122
+ suppliedAmount: string;
2123
+ owedTokens: string;
2124
+ }[];
2125
+ price: string;
2126
+ providerId: string;
2127
+ positionRange?: {
2128
+ fromPrice: string;
2129
+ toPrice: string;
2130
+ } | undefined;
2131
+ }>, "many">;
2132
+ }, "strip", z.ZodTypeAny, {
2133
+ positions: {
2134
+ poolIdentifier: {
2135
+ chainId: string;
2136
+ address: string;
2137
+ };
2138
+ operator: string;
2139
+ suppliedTokens: {
2140
+ tokenUid: {
2141
+ chainId: string;
2142
+ address: string;
2143
+ };
2144
+ suppliedAmount: string;
2145
+ owedTokens: string;
2146
+ }[];
2147
+ price: string;
2148
+ providerId: string;
2149
+ positionRange?: {
2150
+ fromPrice: string;
2151
+ toPrice: string;
2152
+ } | undefined;
2153
+ }[];
2154
+ }, {
2155
+ positions: {
2156
+ poolIdentifier: {
2157
+ chainId: string;
2158
+ address: string;
2159
+ };
2160
+ operator: string;
2161
+ suppliedTokens: {
2162
+ tokenUid: {
2163
+ chainId: string;
2164
+ address: string;
2165
+ };
2166
+ suppliedAmount: string;
2167
+ owedTokens: string;
2168
+ }[];
2169
+ price: string;
2170
+ providerId: string;
2171
+ positionRange?: {
2172
+ fromPrice: string;
2173
+ toPrice: string;
2174
+ } | undefined;
2175
+ }[];
2176
+ }>;
513
2177
  type GetWalletLiquidityPositionsResponse = z.infer<typeof GetWalletLiquidityPositionsResponseSchema>;
514
2178
  declare const GetLiquidityPoolsResponseSchema: z.ZodObject<{
515
2179
  liquidityPools: z.ZodArray<z.ZodObject<{
516
2180
  identifier: z.ZodObject<{
517
2181
  chainId: z.ZodString;
518
2182
  address: z.ZodString;
519
- }, z.core.$strip>;
2183
+ }, "strip", z.ZodTypeAny, {
2184
+ chainId: string;
2185
+ address: string;
2186
+ }, {
2187
+ chainId: string;
2188
+ address: string;
2189
+ }>;
520
2190
  tokens: z.ZodArray<z.ZodObject<{
521
2191
  tokenUid: z.ZodObject<{
522
2192
  chainId: z.ZodString;
523
2193
  address: z.ZodString;
524
- }, z.core.$strip>;
525
- }, z.core.$strip>>;
2194
+ }, "strip", z.ZodTypeAny, {
2195
+ chainId: string;
2196
+ address: string;
2197
+ }, {
2198
+ chainId: string;
2199
+ address: string;
2200
+ }>;
2201
+ }, "strip", z.ZodTypeAny, {
2202
+ tokenUid: {
2203
+ chainId: string;
2204
+ address: string;
2205
+ };
2206
+ }, {
2207
+ tokenUid: {
2208
+ chainId: string;
2209
+ address: string;
2210
+ };
2211
+ }>, "many">;
526
2212
  price: z.ZodString;
527
2213
  providerId: z.ZodString;
528
- }, z.core.$strip>>;
529
- }, z.core.$strip>;
2214
+ }, "strip", z.ZodTypeAny, {
2215
+ price: string;
2216
+ providerId: string;
2217
+ identifier: {
2218
+ chainId: string;
2219
+ address: string;
2220
+ };
2221
+ tokens: {
2222
+ tokenUid: {
2223
+ chainId: string;
2224
+ address: string;
2225
+ };
2226
+ }[];
2227
+ }, {
2228
+ price: string;
2229
+ providerId: string;
2230
+ identifier: {
2231
+ chainId: string;
2232
+ address: string;
2233
+ };
2234
+ tokens: {
2235
+ tokenUid: {
2236
+ chainId: string;
2237
+ address: string;
2238
+ };
2239
+ }[];
2240
+ }>, "many">;
2241
+ }, "strip", z.ZodTypeAny, {
2242
+ liquidityPools: {
2243
+ price: string;
2244
+ providerId: string;
2245
+ identifier: {
2246
+ chainId: string;
2247
+ address: string;
2248
+ };
2249
+ tokens: {
2250
+ tokenUid: {
2251
+ chainId: string;
2252
+ address: string;
2253
+ };
2254
+ }[];
2255
+ }[];
2256
+ }, {
2257
+ liquidityPools: {
2258
+ price: string;
2259
+ providerId: string;
2260
+ identifier: {
2261
+ chainId: string;
2262
+ address: string;
2263
+ };
2264
+ tokens: {
2265
+ tokenUid: {
2266
+ chainId: string;
2267
+ address: string;
2268
+ };
2269
+ }[];
2270
+ }[];
2271
+ }>;
530
2272
  type GetLiquidityPoolsResponse = z.infer<typeof GetLiquidityPoolsResponseSchema>;
531
2273
 
532
2274
  /**
@@ -542,8 +2284,8 @@ type LiquidityWithdrawCallback = (request: WithdrawLiquidityRequest) => Promise<
542
2284
  */
543
2285
  type LiquidityActions = 'liquidity-supply' | 'liquidity-withdraw';
544
2286
 
545
- declare const DecreasePositionSwapTypeSchema: z.ZodEnum<typeof DecreasePositionSwapType>;
546
- declare const PositionSideSchema: z.ZodUnion<readonly [z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
2287
+ declare const DecreasePositionSwapTypeSchema: z.ZodNativeEnum<typeof DecreasePositionSwapType>;
2288
+ declare const PositionSideSchema: z.ZodUnion<[z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
547
2289
  type PositionSide = z.infer<typeof PositionSideSchema>;
548
2290
  declare const PositionSchema: z.ZodObject<{
549
2291
  chainId: z.ZodString;
@@ -558,7 +2300,7 @@ declare const PositionSchema: z.ZodObject<{
558
2300
  pendingBorrowingFeesUsd: z.ZodString;
559
2301
  increasedAtTime: z.ZodString;
560
2302
  decreasedAtTime: z.ZodString;
561
- positionSide: z.ZodUnion<readonly [z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
2303
+ positionSide: z.ZodUnion<[z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
562
2304
  isLong: z.ZodBoolean;
563
2305
  fundingFeeAmount: z.ZodString;
564
2306
  claimableLongTokenAmount: z.ZodString;
@@ -569,7 +2311,55 @@ declare const PositionSchema: z.ZodObject<{
569
2311
  traderDiscountAmount: z.ZodString;
570
2312
  uiFeeAmount: z.ZodString;
571
2313
  data: z.ZodOptional<z.ZodString>;
572
- }, z.core.$strip>;
2314
+ }, "strip", z.ZodTypeAny, {
2315
+ chainId: string;
2316
+ key: string;
2317
+ contractKey: string;
2318
+ account: string;
2319
+ marketAddress: string;
2320
+ collateralTokenAddress: string;
2321
+ sizeInUsd: string;
2322
+ sizeInTokens: string;
2323
+ collateralAmount: string;
2324
+ pendingBorrowingFeesUsd: string;
2325
+ increasedAtTime: string;
2326
+ decreasedAtTime: string;
2327
+ positionSide: "long" | "short";
2328
+ isLong: boolean;
2329
+ fundingFeeAmount: string;
2330
+ claimableLongTokenAmount: string;
2331
+ claimableShortTokenAmount: string;
2332
+ pnl: string;
2333
+ positionFeeAmount: string;
2334
+ traderDiscountAmount: string;
2335
+ uiFeeAmount: string;
2336
+ data?: string | undefined;
2337
+ isOpening?: boolean | undefined;
2338
+ }, {
2339
+ chainId: string;
2340
+ key: string;
2341
+ contractKey: string;
2342
+ account: string;
2343
+ marketAddress: string;
2344
+ collateralTokenAddress: string;
2345
+ sizeInUsd: string;
2346
+ sizeInTokens: string;
2347
+ collateralAmount: string;
2348
+ pendingBorrowingFeesUsd: string;
2349
+ increasedAtTime: string;
2350
+ decreasedAtTime: string;
2351
+ positionSide: "long" | "short";
2352
+ isLong: boolean;
2353
+ fundingFeeAmount: string;
2354
+ claimableLongTokenAmount: string;
2355
+ claimableShortTokenAmount: string;
2356
+ pnl: string;
2357
+ positionFeeAmount: string;
2358
+ traderDiscountAmount: string;
2359
+ uiFeeAmount: string;
2360
+ data?: string | undefined;
2361
+ isOpening?: boolean | undefined;
2362
+ }>;
573
2363
  type PerpetualsPosition = z.infer<typeof PositionSchema>;
574
2364
  declare const PositionsDataSchema: z.ZodArray<z.ZodObject<{
575
2365
  chainId: z.ZodString;
@@ -584,7 +2374,7 @@ declare const PositionsDataSchema: z.ZodArray<z.ZodObject<{
584
2374
  pendingBorrowingFeesUsd: z.ZodString;
585
2375
  increasedAtTime: z.ZodString;
586
2376
  decreasedAtTime: z.ZodString;
587
- positionSide: z.ZodUnion<readonly [z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
2377
+ positionSide: z.ZodUnion<[z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
588
2378
  isLong: z.ZodBoolean;
589
2379
  fundingFeeAmount: z.ZodString;
590
2380
  claimableLongTokenAmount: z.ZodString;
@@ -595,7 +2385,55 @@ declare const PositionsDataSchema: z.ZodArray<z.ZodObject<{
595
2385
  traderDiscountAmount: z.ZodString;
596
2386
  uiFeeAmount: z.ZodString;
597
2387
  data: z.ZodOptional<z.ZodString>;
598
- }, z.core.$strip>>;
2388
+ }, "strip", z.ZodTypeAny, {
2389
+ chainId: string;
2390
+ key: string;
2391
+ contractKey: string;
2392
+ account: string;
2393
+ marketAddress: string;
2394
+ collateralTokenAddress: string;
2395
+ sizeInUsd: string;
2396
+ sizeInTokens: string;
2397
+ collateralAmount: string;
2398
+ pendingBorrowingFeesUsd: string;
2399
+ increasedAtTime: string;
2400
+ decreasedAtTime: string;
2401
+ positionSide: "long" | "short";
2402
+ isLong: boolean;
2403
+ fundingFeeAmount: string;
2404
+ claimableLongTokenAmount: string;
2405
+ claimableShortTokenAmount: string;
2406
+ pnl: string;
2407
+ positionFeeAmount: string;
2408
+ traderDiscountAmount: string;
2409
+ uiFeeAmount: string;
2410
+ data?: string | undefined;
2411
+ isOpening?: boolean | undefined;
2412
+ }, {
2413
+ chainId: string;
2414
+ key: string;
2415
+ contractKey: string;
2416
+ account: string;
2417
+ marketAddress: string;
2418
+ collateralTokenAddress: string;
2419
+ sizeInUsd: string;
2420
+ sizeInTokens: string;
2421
+ collateralAmount: string;
2422
+ pendingBorrowingFeesUsd: string;
2423
+ increasedAtTime: string;
2424
+ decreasedAtTime: string;
2425
+ positionSide: "long" | "short";
2426
+ isLong: boolean;
2427
+ fundingFeeAmount: string;
2428
+ claimableLongTokenAmount: string;
2429
+ claimableShortTokenAmount: string;
2430
+ pnl: string;
2431
+ positionFeeAmount: string;
2432
+ traderDiscountAmount: string;
2433
+ uiFeeAmount: string;
2434
+ data?: string | undefined;
2435
+ isOpening?: boolean | undefined;
2436
+ }>, "many">;
599
2437
  declare const OrderSchema: z.ZodObject<{
600
2438
  chainId: z.ZodString;
601
2439
  key: z.ZodString;
@@ -603,9 +2441,9 @@ declare const OrderSchema: z.ZodObject<{
603
2441
  callbackContract: z.ZodString;
604
2442
  initialCollateralTokenAddress: z.ZodString;
605
2443
  marketAddress: z.ZodString;
606
- decreasePositionSwapType: z.ZodEnum<typeof DecreasePositionSwapType>;
2444
+ decreasePositionSwapType: z.ZodNativeEnum<typeof DecreasePositionSwapType>;
607
2445
  receiver: z.ZodString;
608
- swapPath: z.ZodArray<z.ZodString>;
2446
+ swapPath: z.ZodArray<z.ZodString, "many">;
609
2447
  contractAcceptablePrice: z.ZodString;
610
2448
  contractTriggerPrice: z.ZodString;
611
2449
  callbackGasLimit: z.ZodString;
@@ -615,15 +2453,69 @@ declare const OrderSchema: z.ZodObject<{
615
2453
  sizeDeltaUsd: z.ZodString;
616
2454
  updatedAtTime: z.ZodString;
617
2455
  isFrozen: z.ZodBoolean;
618
- positionSide: z.ZodUnion<readonly [z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
619
- orderType: z.ZodEnum<typeof OrderType>;
2456
+ positionSide: z.ZodUnion<[z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
2457
+ orderType: z.ZodNativeEnum<typeof OrderType>;
620
2458
  shouldUnwrapNativeToken: z.ZodBoolean;
621
2459
  autoCancel: z.ZodBoolean;
622
2460
  data: z.ZodOptional<z.ZodString>;
623
2461
  uiFeeReceiver: z.ZodString;
624
2462
  validFromTime: z.ZodString;
625
2463
  title: z.ZodOptional<z.ZodString>;
626
- }, z.core.$strip>;
2464
+ }, "strip", z.ZodTypeAny, {
2465
+ chainId: string;
2466
+ key: string;
2467
+ account: string;
2468
+ marketAddress: string;
2469
+ positionSide: "long" | "short";
2470
+ callbackContract: string;
2471
+ initialCollateralTokenAddress: string;
2472
+ decreasePositionSwapType: DecreasePositionSwapType;
2473
+ receiver: string;
2474
+ swapPath: string[];
2475
+ contractAcceptablePrice: string;
2476
+ contractTriggerPrice: string;
2477
+ callbackGasLimit: string;
2478
+ executionFee: string;
2479
+ initialCollateralDeltaAmount: string;
2480
+ minOutputAmount: string;
2481
+ sizeDeltaUsd: string;
2482
+ updatedAtTime: string;
2483
+ isFrozen: boolean;
2484
+ orderType: OrderType;
2485
+ shouldUnwrapNativeToken: boolean;
2486
+ autoCancel: boolean;
2487
+ uiFeeReceiver: string;
2488
+ validFromTime: string;
2489
+ data?: string | undefined;
2490
+ title?: string | undefined;
2491
+ }, {
2492
+ chainId: string;
2493
+ key: string;
2494
+ account: string;
2495
+ marketAddress: string;
2496
+ positionSide: "long" | "short";
2497
+ callbackContract: string;
2498
+ initialCollateralTokenAddress: string;
2499
+ decreasePositionSwapType: DecreasePositionSwapType;
2500
+ receiver: string;
2501
+ swapPath: string[];
2502
+ contractAcceptablePrice: string;
2503
+ contractTriggerPrice: string;
2504
+ callbackGasLimit: string;
2505
+ executionFee: string;
2506
+ initialCollateralDeltaAmount: string;
2507
+ minOutputAmount: string;
2508
+ sizeDeltaUsd: string;
2509
+ updatedAtTime: string;
2510
+ isFrozen: boolean;
2511
+ orderType: OrderType;
2512
+ shouldUnwrapNativeToken: boolean;
2513
+ autoCancel: boolean;
2514
+ uiFeeReceiver: string;
2515
+ validFromTime: string;
2516
+ data?: string | undefined;
2517
+ title?: string | undefined;
2518
+ }>;
627
2519
  type PerpetualsOrder = z.infer<typeof OrderSchema>;
628
2520
  declare const OrdersDataSchema: z.ZodArray<z.ZodObject<{
629
2521
  chainId: z.ZodString;
@@ -632,9 +2524,9 @@ declare const OrdersDataSchema: z.ZodArray<z.ZodObject<{
632
2524
  callbackContract: z.ZodString;
633
2525
  initialCollateralTokenAddress: z.ZodString;
634
2526
  marketAddress: z.ZodString;
635
- decreasePositionSwapType: z.ZodEnum<typeof DecreasePositionSwapType>;
2527
+ decreasePositionSwapType: z.ZodNativeEnum<typeof DecreasePositionSwapType>;
636
2528
  receiver: z.ZodString;
637
- swapPath: z.ZodArray<z.ZodString>;
2529
+ swapPath: z.ZodArray<z.ZodString, "many">;
638
2530
  contractAcceptablePrice: z.ZodString;
639
2531
  contractTriggerPrice: z.ZodString;
640
2532
  callbackGasLimit: z.ZodString;
@@ -644,15 +2536,69 @@ declare const OrdersDataSchema: z.ZodArray<z.ZodObject<{
644
2536
  sizeDeltaUsd: z.ZodString;
645
2537
  updatedAtTime: z.ZodString;
646
2538
  isFrozen: z.ZodBoolean;
647
- positionSide: z.ZodUnion<readonly [z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
648
- orderType: z.ZodEnum<typeof OrderType>;
2539
+ positionSide: z.ZodUnion<[z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
2540
+ orderType: z.ZodNativeEnum<typeof OrderType>;
649
2541
  shouldUnwrapNativeToken: z.ZodBoolean;
650
2542
  autoCancel: z.ZodBoolean;
651
2543
  data: z.ZodOptional<z.ZodString>;
652
2544
  uiFeeReceiver: z.ZodString;
653
2545
  validFromTime: z.ZodString;
654
2546
  title: z.ZodOptional<z.ZodString>;
655
- }, z.core.$strip>>;
2547
+ }, "strip", z.ZodTypeAny, {
2548
+ chainId: string;
2549
+ key: string;
2550
+ account: string;
2551
+ marketAddress: string;
2552
+ positionSide: "long" | "short";
2553
+ callbackContract: string;
2554
+ initialCollateralTokenAddress: string;
2555
+ decreasePositionSwapType: DecreasePositionSwapType;
2556
+ receiver: string;
2557
+ swapPath: string[];
2558
+ contractAcceptablePrice: string;
2559
+ contractTriggerPrice: string;
2560
+ callbackGasLimit: string;
2561
+ executionFee: string;
2562
+ initialCollateralDeltaAmount: string;
2563
+ minOutputAmount: string;
2564
+ sizeDeltaUsd: string;
2565
+ updatedAtTime: string;
2566
+ isFrozen: boolean;
2567
+ orderType: OrderType;
2568
+ shouldUnwrapNativeToken: boolean;
2569
+ autoCancel: boolean;
2570
+ uiFeeReceiver: string;
2571
+ validFromTime: string;
2572
+ data?: string | undefined;
2573
+ title?: string | undefined;
2574
+ }, {
2575
+ chainId: string;
2576
+ key: string;
2577
+ account: string;
2578
+ marketAddress: string;
2579
+ positionSide: "long" | "short";
2580
+ callbackContract: string;
2581
+ initialCollateralTokenAddress: string;
2582
+ decreasePositionSwapType: DecreasePositionSwapType;
2583
+ receiver: string;
2584
+ swapPath: string[];
2585
+ contractAcceptablePrice: string;
2586
+ contractTriggerPrice: string;
2587
+ callbackGasLimit: string;
2588
+ executionFee: string;
2589
+ initialCollateralDeltaAmount: string;
2590
+ minOutputAmount: string;
2591
+ sizeDeltaUsd: string;
2592
+ updatedAtTime: string;
2593
+ isFrozen: boolean;
2594
+ orderType: OrderType;
2595
+ shouldUnwrapNativeToken: boolean;
2596
+ autoCancel: boolean;
2597
+ uiFeeReceiver: string;
2598
+ validFromTime: string;
2599
+ data?: string | undefined;
2600
+ title?: string | undefined;
2601
+ }>, "many">;
656
2602
  declare const CreatePerpetualsPositionRequestSchema: z.ZodObject<{
657
2603
  amount: z.ZodBigInt;
658
2604
  walletAddress: z.ZodString;
@@ -663,23 +2609,73 @@ declare const CreatePerpetualsPositionRequestSchema: z.ZodObject<{
663
2609
  referralCode: z.ZodOptional<z.ZodString>;
664
2610
  limitPrice: z.ZodOptional<z.ZodString>;
665
2611
  leverage: z.ZodString;
666
- }, z.core.$strip>;
2612
+ }, "strip", z.ZodTypeAny, {
2613
+ chainId: string;
2614
+ amount: bigint;
2615
+ walletAddress: string;
2616
+ marketAddress: string;
2617
+ collateralTokenAddress: string;
2618
+ payTokenAddress: string;
2619
+ leverage: string;
2620
+ limitPrice?: string | undefined;
2621
+ referralCode?: string | undefined;
2622
+ }, {
2623
+ chainId: string;
2624
+ amount: bigint;
2625
+ walletAddress: string;
2626
+ marketAddress: string;
2627
+ collateralTokenAddress: string;
2628
+ payTokenAddress: string;
2629
+ leverage: string;
2630
+ limitPrice?: string | undefined;
2631
+ referralCode?: string | undefined;
2632
+ }>;
667
2633
  type CreatePerpetualsPositionRequest = z.infer<typeof CreatePerpetualsPositionRequestSchema>;
668
2634
  declare const CreatePerpetualsPositionResponseSchema: z.ZodObject<{
669
2635
  transactions: z.ZodArray<z.ZodObject<{
670
- type: z.ZodEnum<{
671
- [x: string]: string;
672
- }>;
2636
+ type: z.ZodEnum<[string, ...string[]]>;
673
2637
  to: z.ZodString;
674
2638
  data: z.ZodString;
675
2639
  value: z.ZodString;
676
2640
  chainId: z.ZodString;
677
- }, z.core.$strip>>;
678
- }, z.core.$strip>;
2641
+ }, "strip", z.ZodTypeAny, {
2642
+ value: string;
2643
+ type: string;
2644
+ chainId: string;
2645
+ to: string;
2646
+ data: string;
2647
+ }, {
2648
+ value: string;
2649
+ type: string;
2650
+ chainId: string;
2651
+ to: string;
2652
+ data: string;
2653
+ }>, "many">;
2654
+ }, "strip", z.ZodTypeAny, {
2655
+ transactions: {
2656
+ value: string;
2657
+ type: string;
2658
+ chainId: string;
2659
+ to: string;
2660
+ data: string;
2661
+ }[];
2662
+ }, {
2663
+ transactions: {
2664
+ value: string;
2665
+ type: string;
2666
+ chainId: string;
2667
+ to: string;
2668
+ data: string;
2669
+ }[];
2670
+ }>;
679
2671
  type CreatePerpetualsPositionResponse = z.infer<typeof CreatePerpetualsPositionResponseSchema>;
680
2672
  declare const GetPerpetualsMarketsPositionsRequestSchema: z.ZodObject<{
681
2673
  walletAddress: z.ZodString;
682
- }, z.core.$strip>;
2674
+ }, "strip", z.ZodTypeAny, {
2675
+ walletAddress: string;
2676
+ }, {
2677
+ walletAddress: string;
2678
+ }>;
683
2679
  type GetPerpetualsMarketsPositionsRequest = z.infer<typeof GetPerpetualsMarketsPositionsRequestSchema>;
684
2680
  declare const GetPerpetualsMarketsPositionsResponseSchema: z.ZodObject<{
685
2681
  positions: z.ZodArray<z.ZodObject<{
@@ -695,7 +2691,7 @@ declare const GetPerpetualsMarketsPositionsResponseSchema: z.ZodObject<{
695
2691
  pendingBorrowingFeesUsd: z.ZodString;
696
2692
  increasedAtTime: z.ZodString;
697
2693
  decreasedAtTime: z.ZodString;
698
- positionSide: z.ZodUnion<readonly [z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
2694
+ positionSide: z.ZodUnion<[z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
699
2695
  isLong: z.ZodBoolean;
700
2696
  fundingFeeAmount: z.ZodString;
701
2697
  claimableLongTokenAmount: z.ZodString;
@@ -706,12 +2702,116 @@ declare const GetPerpetualsMarketsPositionsResponseSchema: z.ZodObject<{
706
2702
  traderDiscountAmount: z.ZodString;
707
2703
  uiFeeAmount: z.ZodString;
708
2704
  data: z.ZodOptional<z.ZodString>;
709
- }, z.core.$strip>>;
710
- }, z.core.$strip>;
2705
+ }, "strip", z.ZodTypeAny, {
2706
+ chainId: string;
2707
+ key: string;
2708
+ contractKey: string;
2709
+ account: string;
2710
+ marketAddress: string;
2711
+ collateralTokenAddress: string;
2712
+ sizeInUsd: string;
2713
+ sizeInTokens: string;
2714
+ collateralAmount: string;
2715
+ pendingBorrowingFeesUsd: string;
2716
+ increasedAtTime: string;
2717
+ decreasedAtTime: string;
2718
+ positionSide: "long" | "short";
2719
+ isLong: boolean;
2720
+ fundingFeeAmount: string;
2721
+ claimableLongTokenAmount: string;
2722
+ claimableShortTokenAmount: string;
2723
+ pnl: string;
2724
+ positionFeeAmount: string;
2725
+ traderDiscountAmount: string;
2726
+ uiFeeAmount: string;
2727
+ data?: string | undefined;
2728
+ isOpening?: boolean | undefined;
2729
+ }, {
2730
+ chainId: string;
2731
+ key: string;
2732
+ contractKey: string;
2733
+ account: string;
2734
+ marketAddress: string;
2735
+ collateralTokenAddress: string;
2736
+ sizeInUsd: string;
2737
+ sizeInTokens: string;
2738
+ collateralAmount: string;
2739
+ pendingBorrowingFeesUsd: string;
2740
+ increasedAtTime: string;
2741
+ decreasedAtTime: string;
2742
+ positionSide: "long" | "short";
2743
+ isLong: boolean;
2744
+ fundingFeeAmount: string;
2745
+ claimableLongTokenAmount: string;
2746
+ claimableShortTokenAmount: string;
2747
+ pnl: string;
2748
+ positionFeeAmount: string;
2749
+ traderDiscountAmount: string;
2750
+ uiFeeAmount: string;
2751
+ data?: string | undefined;
2752
+ isOpening?: boolean | undefined;
2753
+ }>, "many">;
2754
+ }, "strip", z.ZodTypeAny, {
2755
+ positions: {
2756
+ chainId: string;
2757
+ key: string;
2758
+ contractKey: string;
2759
+ account: string;
2760
+ marketAddress: string;
2761
+ collateralTokenAddress: string;
2762
+ sizeInUsd: string;
2763
+ sizeInTokens: string;
2764
+ collateralAmount: string;
2765
+ pendingBorrowingFeesUsd: string;
2766
+ increasedAtTime: string;
2767
+ decreasedAtTime: string;
2768
+ positionSide: "long" | "short";
2769
+ isLong: boolean;
2770
+ fundingFeeAmount: string;
2771
+ claimableLongTokenAmount: string;
2772
+ claimableShortTokenAmount: string;
2773
+ pnl: string;
2774
+ positionFeeAmount: string;
2775
+ traderDiscountAmount: string;
2776
+ uiFeeAmount: string;
2777
+ data?: string | undefined;
2778
+ isOpening?: boolean | undefined;
2779
+ }[];
2780
+ }, {
2781
+ positions: {
2782
+ chainId: string;
2783
+ key: string;
2784
+ contractKey: string;
2785
+ account: string;
2786
+ marketAddress: string;
2787
+ collateralTokenAddress: string;
2788
+ sizeInUsd: string;
2789
+ sizeInTokens: string;
2790
+ collateralAmount: string;
2791
+ pendingBorrowingFeesUsd: string;
2792
+ increasedAtTime: string;
2793
+ decreasedAtTime: string;
2794
+ positionSide: "long" | "short";
2795
+ isLong: boolean;
2796
+ fundingFeeAmount: string;
2797
+ claimableLongTokenAmount: string;
2798
+ claimableShortTokenAmount: string;
2799
+ pnl: string;
2800
+ positionFeeAmount: string;
2801
+ traderDiscountAmount: string;
2802
+ uiFeeAmount: string;
2803
+ data?: string | undefined;
2804
+ isOpening?: boolean | undefined;
2805
+ }[];
2806
+ }>;
711
2807
  type GetPerpetualsMarketsPositionsResponse = z.infer<typeof GetPerpetualsMarketsPositionsResponseSchema>;
712
2808
  declare const GetPerpetualsMarketsOrdersRequestSchema: z.ZodObject<{
713
2809
  walletAddress: z.ZodString;
714
- }, z.core.$strip>;
2810
+ }, "strip", z.ZodTypeAny, {
2811
+ walletAddress: string;
2812
+ }, {
2813
+ walletAddress: string;
2814
+ }>;
715
2815
  type GetPerpetualsMarketsOrdersRequest = z.infer<typeof GetPerpetualsMarketsOrdersRequestSchema>;
716
2816
  declare const GetPerpetualsMarketsOrdersResponseSchema: z.ZodObject<{
717
2817
  orders: z.ZodArray<z.ZodObject<{
@@ -721,9 +2821,9 @@ declare const GetPerpetualsMarketsOrdersResponseSchema: z.ZodObject<{
721
2821
  callbackContract: z.ZodString;
722
2822
  initialCollateralTokenAddress: z.ZodString;
723
2823
  marketAddress: z.ZodString;
724
- decreasePositionSwapType: z.ZodEnum<typeof DecreasePositionSwapType>;
2824
+ decreasePositionSwapType: z.ZodNativeEnum<typeof DecreasePositionSwapType>;
725
2825
  receiver: z.ZodString;
726
- swapPath: z.ZodArray<z.ZodString>;
2826
+ swapPath: z.ZodArray<z.ZodString, "many">;
727
2827
  contractAcceptablePrice: z.ZodString;
728
2828
  contractTriggerPrice: z.ZodString;
729
2829
  callbackGasLimit: z.ZodString;
@@ -733,89 +2833,427 @@ declare const GetPerpetualsMarketsOrdersResponseSchema: z.ZodObject<{
733
2833
  sizeDeltaUsd: z.ZodString;
734
2834
  updatedAtTime: z.ZodString;
735
2835
  isFrozen: z.ZodBoolean;
736
- positionSide: z.ZodUnion<readonly [z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
737
- orderType: z.ZodEnum<typeof OrderType>;
2836
+ positionSide: z.ZodUnion<[z.ZodLiteral<"long">, z.ZodLiteral<"short">]>;
2837
+ orderType: z.ZodNativeEnum<typeof OrderType>;
738
2838
  shouldUnwrapNativeToken: z.ZodBoolean;
739
2839
  autoCancel: z.ZodBoolean;
740
2840
  data: z.ZodOptional<z.ZodString>;
741
2841
  uiFeeReceiver: z.ZodString;
742
2842
  validFromTime: z.ZodString;
743
2843
  title: z.ZodOptional<z.ZodString>;
744
- }, z.core.$strip>>;
745
- }, z.core.$strip>;
2844
+ }, "strip", z.ZodTypeAny, {
2845
+ chainId: string;
2846
+ key: string;
2847
+ account: string;
2848
+ marketAddress: string;
2849
+ positionSide: "long" | "short";
2850
+ callbackContract: string;
2851
+ initialCollateralTokenAddress: string;
2852
+ decreasePositionSwapType: DecreasePositionSwapType;
2853
+ receiver: string;
2854
+ swapPath: string[];
2855
+ contractAcceptablePrice: string;
2856
+ contractTriggerPrice: string;
2857
+ callbackGasLimit: string;
2858
+ executionFee: string;
2859
+ initialCollateralDeltaAmount: string;
2860
+ minOutputAmount: string;
2861
+ sizeDeltaUsd: string;
2862
+ updatedAtTime: string;
2863
+ isFrozen: boolean;
2864
+ orderType: OrderType;
2865
+ shouldUnwrapNativeToken: boolean;
2866
+ autoCancel: boolean;
2867
+ uiFeeReceiver: string;
2868
+ validFromTime: string;
2869
+ data?: string | undefined;
2870
+ title?: string | undefined;
2871
+ }, {
2872
+ chainId: string;
2873
+ key: string;
2874
+ account: string;
2875
+ marketAddress: string;
2876
+ positionSide: "long" | "short";
2877
+ callbackContract: string;
2878
+ initialCollateralTokenAddress: string;
2879
+ decreasePositionSwapType: DecreasePositionSwapType;
2880
+ receiver: string;
2881
+ swapPath: string[];
2882
+ contractAcceptablePrice: string;
2883
+ contractTriggerPrice: string;
2884
+ callbackGasLimit: string;
2885
+ executionFee: string;
2886
+ initialCollateralDeltaAmount: string;
2887
+ minOutputAmount: string;
2888
+ sizeDeltaUsd: string;
2889
+ updatedAtTime: string;
2890
+ isFrozen: boolean;
2891
+ orderType: OrderType;
2892
+ shouldUnwrapNativeToken: boolean;
2893
+ autoCancel: boolean;
2894
+ uiFeeReceiver: string;
2895
+ validFromTime: string;
2896
+ data?: string | undefined;
2897
+ title?: string | undefined;
2898
+ }>, "many">;
2899
+ }, "strip", z.ZodTypeAny, {
2900
+ orders: {
2901
+ chainId: string;
2902
+ key: string;
2903
+ account: string;
2904
+ marketAddress: string;
2905
+ positionSide: "long" | "short";
2906
+ callbackContract: string;
2907
+ initialCollateralTokenAddress: string;
2908
+ decreasePositionSwapType: DecreasePositionSwapType;
2909
+ receiver: string;
2910
+ swapPath: string[];
2911
+ contractAcceptablePrice: string;
2912
+ contractTriggerPrice: string;
2913
+ callbackGasLimit: string;
2914
+ executionFee: string;
2915
+ initialCollateralDeltaAmount: string;
2916
+ minOutputAmount: string;
2917
+ sizeDeltaUsd: string;
2918
+ updatedAtTime: string;
2919
+ isFrozen: boolean;
2920
+ orderType: OrderType;
2921
+ shouldUnwrapNativeToken: boolean;
2922
+ autoCancel: boolean;
2923
+ uiFeeReceiver: string;
2924
+ validFromTime: string;
2925
+ data?: string | undefined;
2926
+ title?: string | undefined;
2927
+ }[];
2928
+ }, {
2929
+ orders: {
2930
+ chainId: string;
2931
+ key: string;
2932
+ account: string;
2933
+ marketAddress: string;
2934
+ positionSide: "long" | "short";
2935
+ callbackContract: string;
2936
+ initialCollateralTokenAddress: string;
2937
+ decreasePositionSwapType: DecreasePositionSwapType;
2938
+ receiver: string;
2939
+ swapPath: string[];
2940
+ contractAcceptablePrice: string;
2941
+ contractTriggerPrice: string;
2942
+ callbackGasLimit: string;
2943
+ executionFee: string;
2944
+ initialCollateralDeltaAmount: string;
2945
+ minOutputAmount: string;
2946
+ sizeDeltaUsd: string;
2947
+ updatedAtTime: string;
2948
+ isFrozen: boolean;
2949
+ orderType: OrderType;
2950
+ shouldUnwrapNativeToken: boolean;
2951
+ autoCancel: boolean;
2952
+ uiFeeReceiver: string;
2953
+ validFromTime: string;
2954
+ data?: string | undefined;
2955
+ title?: string | undefined;
2956
+ }[];
2957
+ }>;
746
2958
  type GetPerpetualsMarketsOrdersResponse = z.infer<typeof GetPerpetualsMarketsOrdersResponseSchema>;
747
2959
  declare const ClosePerpetualsOrdersRequestSchema: z.ZodObject<{
748
2960
  walletAddress: z.ZodString;
749
2961
  key: z.ZodString;
750
- }, z.core.$strip>;
2962
+ }, "strip", z.ZodTypeAny, {
2963
+ walletAddress: string;
2964
+ key: string;
2965
+ }, {
2966
+ walletAddress: string;
2967
+ key: string;
2968
+ }>;
751
2969
  type ClosePerpetualsOrdersRequest = z.infer<typeof ClosePerpetualsOrdersRequestSchema>;
752
2970
  declare const ClosePerpetualsOrdersResponseSchema: z.ZodObject<{
753
2971
  transactions: z.ZodArray<z.ZodObject<{
754
- type: z.ZodEnum<{
755
- [x: string]: string;
756
- }>;
2972
+ type: z.ZodEnum<[string, ...string[]]>;
757
2973
  to: z.ZodString;
758
2974
  data: z.ZodString;
759
2975
  value: z.ZodString;
760
2976
  chainId: z.ZodString;
761
- }, z.core.$strip>>;
762
- }, z.core.$strip>;
2977
+ }, "strip", z.ZodTypeAny, {
2978
+ value: string;
2979
+ type: string;
2980
+ chainId: string;
2981
+ to: string;
2982
+ data: string;
2983
+ }, {
2984
+ value: string;
2985
+ type: string;
2986
+ chainId: string;
2987
+ to: string;
2988
+ data: string;
2989
+ }>, "many">;
2990
+ }, "strip", z.ZodTypeAny, {
2991
+ transactions: {
2992
+ value: string;
2993
+ type: string;
2994
+ chainId: string;
2995
+ to: string;
2996
+ data: string;
2997
+ }[];
2998
+ }, {
2999
+ transactions: {
3000
+ value: string;
3001
+ type: string;
3002
+ chainId: string;
3003
+ to: string;
3004
+ data: string;
3005
+ }[];
3006
+ }>;
763
3007
  type ClosePerpetualsOrdersResponse = z.infer<typeof ClosePerpetualsOrdersResponseSchema>;
764
3008
  declare const GetPerpetualsMarketsRequestSchema: z.ZodObject<{
765
- chainIds: z.ZodArray<z.ZodString>;
766
- }, z.core.$strip>;
3009
+ chainIds: z.ZodArray<z.ZodString, "many">;
3010
+ }, "strip", z.ZodTypeAny, {
3011
+ chainIds: string[];
3012
+ }, {
3013
+ chainIds: string[];
3014
+ }>;
767
3015
  type GetPerpetualsMarketsRequest = z.infer<typeof GetPerpetualsMarketsRequestSchema>;
768
3016
  declare const PerpetualMarketSchema: z.ZodObject<{
769
3017
  marketToken: z.ZodObject<{
770
3018
  chainId: z.ZodString;
771
3019
  address: z.ZodString;
772
- }, z.core.$strip>;
3020
+ }, "strip", z.ZodTypeAny, {
3021
+ chainId: string;
3022
+ address: string;
3023
+ }, {
3024
+ chainId: string;
3025
+ address: string;
3026
+ }>;
773
3027
  indexToken: z.ZodObject<{
774
3028
  chainId: z.ZodString;
775
3029
  address: z.ZodString;
776
- }, z.core.$strip>;
3030
+ }, "strip", z.ZodTypeAny, {
3031
+ chainId: string;
3032
+ address: string;
3033
+ }, {
3034
+ chainId: string;
3035
+ address: string;
3036
+ }>;
777
3037
  longToken: z.ZodObject<{
778
3038
  chainId: z.ZodString;
779
3039
  address: z.ZodString;
780
- }, z.core.$strip>;
3040
+ }, "strip", z.ZodTypeAny, {
3041
+ chainId: string;
3042
+ address: string;
3043
+ }, {
3044
+ chainId: string;
3045
+ address: string;
3046
+ }>;
781
3047
  shortToken: z.ZodObject<{
782
3048
  chainId: z.ZodString;
783
3049
  address: z.ZodString;
784
- }, z.core.$strip>;
3050
+ }, "strip", z.ZodTypeAny, {
3051
+ chainId: string;
3052
+ address: string;
3053
+ }, {
3054
+ chainId: string;
3055
+ address: string;
3056
+ }>;
785
3057
  longFundingFee: z.ZodString;
786
3058
  shortFundingFee: z.ZodString;
787
3059
  longBorrowingFee: z.ZodString;
788
3060
  shortBorrowingFee: z.ZodString;
789
3061
  chainId: z.ZodString;
790
3062
  name: z.ZodString;
791
- }, z.core.$strip>;
3063
+ }, "strip", z.ZodTypeAny, {
3064
+ chainId: string;
3065
+ name: string;
3066
+ marketToken: {
3067
+ chainId: string;
3068
+ address: string;
3069
+ };
3070
+ indexToken: {
3071
+ chainId: string;
3072
+ address: string;
3073
+ };
3074
+ longToken: {
3075
+ chainId: string;
3076
+ address: string;
3077
+ };
3078
+ shortToken: {
3079
+ chainId: string;
3080
+ address: string;
3081
+ };
3082
+ longFundingFee: string;
3083
+ shortFundingFee: string;
3084
+ longBorrowingFee: string;
3085
+ shortBorrowingFee: string;
3086
+ }, {
3087
+ chainId: string;
3088
+ name: string;
3089
+ marketToken: {
3090
+ chainId: string;
3091
+ address: string;
3092
+ };
3093
+ indexToken: {
3094
+ chainId: string;
3095
+ address: string;
3096
+ };
3097
+ longToken: {
3098
+ chainId: string;
3099
+ address: string;
3100
+ };
3101
+ shortToken: {
3102
+ chainId: string;
3103
+ address: string;
3104
+ };
3105
+ longFundingFee: string;
3106
+ shortFundingFee: string;
3107
+ longBorrowingFee: string;
3108
+ shortBorrowingFee: string;
3109
+ }>;
792
3110
  type PerpetualMarket = z.infer<typeof PerpetualMarketSchema>;
793
3111
  declare const GetPerpetualsMarketsResponseSchema: z.ZodObject<{
794
3112
  markets: z.ZodArray<z.ZodObject<{
795
3113
  marketToken: z.ZodObject<{
796
3114
  chainId: z.ZodString;
797
3115
  address: z.ZodString;
798
- }, z.core.$strip>;
3116
+ }, "strip", z.ZodTypeAny, {
3117
+ chainId: string;
3118
+ address: string;
3119
+ }, {
3120
+ chainId: string;
3121
+ address: string;
3122
+ }>;
799
3123
  indexToken: z.ZodObject<{
800
3124
  chainId: z.ZodString;
801
3125
  address: z.ZodString;
802
- }, z.core.$strip>;
3126
+ }, "strip", z.ZodTypeAny, {
3127
+ chainId: string;
3128
+ address: string;
3129
+ }, {
3130
+ chainId: string;
3131
+ address: string;
3132
+ }>;
803
3133
  longToken: z.ZodObject<{
804
3134
  chainId: z.ZodString;
805
3135
  address: z.ZodString;
806
- }, z.core.$strip>;
3136
+ }, "strip", z.ZodTypeAny, {
3137
+ chainId: string;
3138
+ address: string;
3139
+ }, {
3140
+ chainId: string;
3141
+ address: string;
3142
+ }>;
807
3143
  shortToken: z.ZodObject<{
808
3144
  chainId: z.ZodString;
809
3145
  address: z.ZodString;
810
- }, z.core.$strip>;
3146
+ }, "strip", z.ZodTypeAny, {
3147
+ chainId: string;
3148
+ address: string;
3149
+ }, {
3150
+ chainId: string;
3151
+ address: string;
3152
+ }>;
811
3153
  longFundingFee: z.ZodString;
812
3154
  shortFundingFee: z.ZodString;
813
3155
  longBorrowingFee: z.ZodString;
814
3156
  shortBorrowingFee: z.ZodString;
815
3157
  chainId: z.ZodString;
816
3158
  name: z.ZodString;
817
- }, z.core.$strip>>;
818
- }, z.core.$strip>;
3159
+ }, "strip", z.ZodTypeAny, {
3160
+ chainId: string;
3161
+ name: string;
3162
+ marketToken: {
3163
+ chainId: string;
3164
+ address: string;
3165
+ };
3166
+ indexToken: {
3167
+ chainId: string;
3168
+ address: string;
3169
+ };
3170
+ longToken: {
3171
+ chainId: string;
3172
+ address: string;
3173
+ };
3174
+ shortToken: {
3175
+ chainId: string;
3176
+ address: string;
3177
+ };
3178
+ longFundingFee: string;
3179
+ shortFundingFee: string;
3180
+ longBorrowingFee: string;
3181
+ shortBorrowingFee: string;
3182
+ }, {
3183
+ chainId: string;
3184
+ name: string;
3185
+ marketToken: {
3186
+ chainId: string;
3187
+ address: string;
3188
+ };
3189
+ indexToken: {
3190
+ chainId: string;
3191
+ address: string;
3192
+ };
3193
+ longToken: {
3194
+ chainId: string;
3195
+ address: string;
3196
+ };
3197
+ shortToken: {
3198
+ chainId: string;
3199
+ address: string;
3200
+ };
3201
+ longFundingFee: string;
3202
+ shortFundingFee: string;
3203
+ longBorrowingFee: string;
3204
+ shortBorrowingFee: string;
3205
+ }>, "many">;
3206
+ }, "strip", z.ZodTypeAny, {
3207
+ markets: {
3208
+ chainId: string;
3209
+ name: string;
3210
+ marketToken: {
3211
+ chainId: string;
3212
+ address: string;
3213
+ };
3214
+ indexToken: {
3215
+ chainId: string;
3216
+ address: string;
3217
+ };
3218
+ longToken: {
3219
+ chainId: string;
3220
+ address: string;
3221
+ };
3222
+ shortToken: {
3223
+ chainId: string;
3224
+ address: string;
3225
+ };
3226
+ longFundingFee: string;
3227
+ shortFundingFee: string;
3228
+ longBorrowingFee: string;
3229
+ shortBorrowingFee: string;
3230
+ }[];
3231
+ }, {
3232
+ markets: {
3233
+ chainId: string;
3234
+ name: string;
3235
+ marketToken: {
3236
+ chainId: string;
3237
+ address: string;
3238
+ };
3239
+ indexToken: {
3240
+ chainId: string;
3241
+ address: string;
3242
+ };
3243
+ longToken: {
3244
+ chainId: string;
3245
+ address: string;
3246
+ };
3247
+ shortToken: {
3248
+ chainId: string;
3249
+ address: string;
3250
+ };
3251
+ longFundingFee: string;
3252
+ shortFundingFee: string;
3253
+ longBorrowingFee: string;
3254
+ shortBorrowingFee: string;
3255
+ }[];
3256
+ }>;
819
3257
  type GetPerpetualsMarketsResponse = z.infer<typeof GetPerpetualsMarketsResponseSchema>;
820
3258
 
821
3259
  type PerpetualsCreateShortPositionCallback = (request: CreatePerpetualsPositionRequest) => Promise<CreatePerpetualsPositionResponse>;
@@ -950,81 +3388,220 @@ type AvailableQueries = {
950
3388
  declare const TokenIdentifierSchema: z.ZodObject<{
951
3389
  chainId: z.ZodString;
952
3390
  address: z.ZodString;
953
- }, z.core.$strip>;
3391
+ }, "strip", z.ZodTypeAny, {
3392
+ chainId: string;
3393
+ address: string;
3394
+ }, {
3395
+ chainId: string;
3396
+ address: string;
3397
+ }>;
954
3398
  type TokenIdentifier = z.infer<typeof TokenIdentifierSchema>;
955
3399
  declare const TokenSchema: z.ZodObject<{
956
3400
  tokenUid: z.ZodObject<{
957
3401
  chainId: z.ZodString;
958
3402
  address: z.ZodString;
959
- }, z.core.$strip>;
3403
+ }, "strip", z.ZodTypeAny, {
3404
+ chainId: string;
3405
+ address: string;
3406
+ }, {
3407
+ chainId: string;
3408
+ address: string;
3409
+ }>;
960
3410
  name: z.ZodString;
961
3411
  symbol: z.ZodString;
962
3412
  isNative: z.ZodBoolean;
963
3413
  decimals: z.ZodNumber;
964
3414
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
965
3415
  isVetted: z.ZodBoolean;
966
- }, z.core.$strip>;
3416
+ }, "strip", z.ZodTypeAny, {
3417
+ symbol: string;
3418
+ tokenUid: {
3419
+ chainId: string;
3420
+ address: string;
3421
+ };
3422
+ name: string;
3423
+ isNative: boolean;
3424
+ decimals: number;
3425
+ isVetted: boolean;
3426
+ iconUri?: string | null | undefined;
3427
+ }, {
3428
+ symbol: string;
3429
+ tokenUid: {
3430
+ chainId: string;
3431
+ address: string;
3432
+ };
3433
+ name: string;
3434
+ isNative: boolean;
3435
+ decimals: number;
3436
+ isVetted: boolean;
3437
+ iconUri?: string | null | undefined;
3438
+ }>;
967
3439
  type Token = z.infer<typeof TokenSchema>;
968
3440
  declare const ChainSchema: z.ZodObject<{
969
3441
  chainId: z.ZodString;
970
- type: z.ZodEnum<{
971
- UNSPECIFIED: "UNSPECIFIED";
972
- EVM: "EVM";
973
- SOLANA: "SOLANA";
974
- COSMOS: "COSMOS";
975
- }>;
3442
+ type: z.ZodEnum<["UNSPECIFIED", "EVM", "SOLANA", "COSMOS"]>;
976
3443
  iconUri: z.ZodString;
977
3444
  nativeToken: z.ZodObject<{
978
3445
  tokenUid: z.ZodObject<{
979
3446
  chainId: z.ZodString;
980
3447
  address: z.ZodString;
981
- }, z.core.$strip>;
3448
+ }, "strip", z.ZodTypeAny, {
3449
+ chainId: string;
3450
+ address: string;
3451
+ }, {
3452
+ chainId: string;
3453
+ address: string;
3454
+ }>;
982
3455
  name: z.ZodString;
983
3456
  symbol: z.ZodString;
984
3457
  isNative: z.ZodBoolean;
985
3458
  decimals: z.ZodNumber;
986
3459
  iconUri: z.ZodOptional<z.ZodNullable<z.ZodString>>;
987
3460
  isVetted: z.ZodBoolean;
988
- }, z.core.$strip>;
3461
+ }, "strip", z.ZodTypeAny, {
3462
+ symbol: string;
3463
+ tokenUid: {
3464
+ chainId: string;
3465
+ address: string;
3466
+ };
3467
+ name: string;
3468
+ isNative: boolean;
3469
+ decimals: number;
3470
+ isVetted: boolean;
3471
+ iconUri?: string | null | undefined;
3472
+ }, {
3473
+ symbol: string;
3474
+ tokenUid: {
3475
+ chainId: string;
3476
+ address: string;
3477
+ };
3478
+ name: string;
3479
+ isNative: boolean;
3480
+ decimals: number;
3481
+ isVetted: boolean;
3482
+ iconUri?: string | null | undefined;
3483
+ }>;
989
3484
  httpRpcUrl: z.ZodString;
990
3485
  name: z.ZodString;
991
- blockExplorerUrls: z.ZodArray<z.ZodString>;
992
- }, z.core.$strip>;
3486
+ blockExplorerUrls: z.ZodArray<z.ZodString, "many">;
3487
+ }, "strip", z.ZodTypeAny, {
3488
+ type: "UNSPECIFIED" | "EVM" | "SOLANA" | "COSMOS";
3489
+ chainId: string;
3490
+ name: string;
3491
+ iconUri: string;
3492
+ nativeToken: {
3493
+ symbol: string;
3494
+ tokenUid: {
3495
+ chainId: string;
3496
+ address: string;
3497
+ };
3498
+ name: string;
3499
+ isNative: boolean;
3500
+ decimals: number;
3501
+ isVetted: boolean;
3502
+ iconUri?: string | null | undefined;
3503
+ };
3504
+ httpRpcUrl: string;
3505
+ blockExplorerUrls: string[];
3506
+ }, {
3507
+ type: "UNSPECIFIED" | "EVM" | "SOLANA" | "COSMOS";
3508
+ chainId: string;
3509
+ name: string;
3510
+ iconUri: string;
3511
+ nativeToken: {
3512
+ symbol: string;
3513
+ tokenUid: {
3514
+ chainId: string;
3515
+ address: string;
3516
+ };
3517
+ name: string;
3518
+ isNative: boolean;
3519
+ decimals: number;
3520
+ isVetted: boolean;
3521
+ iconUri?: string | null | undefined;
3522
+ };
3523
+ httpRpcUrl: string;
3524
+ blockExplorerUrls: string[];
3525
+ }>;
993
3526
  type Chain = z.infer<typeof ChainSchema>;
994
3527
  declare const FeeBreakdownSchema: z.ZodObject<{
995
3528
  serviceFee: z.ZodString;
996
3529
  slippageCost: z.ZodString;
997
3530
  total: z.ZodString;
998
3531
  feeDenomination: z.ZodString;
999
- }, z.core.$strip>;
3532
+ }, "strip", z.ZodTypeAny, {
3533
+ serviceFee: string;
3534
+ slippageCost: string;
3535
+ total: string;
3536
+ feeDenomination: string;
3537
+ }, {
3538
+ serviceFee: string;
3539
+ slippageCost: string;
3540
+ total: string;
3541
+ feeDenomination: string;
3542
+ }>;
1000
3543
  type FeeBreakdown = z.infer<typeof FeeBreakdownSchema>;
1001
3544
  declare const TransactionPlanSchema: z.ZodObject<{
1002
- type: z.ZodEnum<{
1003
- [x: string]: string;
1004
- }>;
3545
+ type: z.ZodEnum<[string, ...string[]]>;
1005
3546
  to: z.ZodString;
1006
3547
  data: z.ZodString;
1007
3548
  value: z.ZodString;
1008
3549
  chainId: z.ZodString;
1009
- }, z.core.$strip>;
3550
+ }, "strip", z.ZodTypeAny, {
3551
+ value: string;
3552
+ type: string;
3553
+ chainId: string;
3554
+ to: string;
3555
+ data: string;
3556
+ }, {
3557
+ value: string;
3558
+ type: string;
3559
+ chainId: string;
3560
+ to: string;
3561
+ data: string;
3562
+ }>;
1010
3563
  type TransactionPlan = z.infer<typeof TransactionPlanSchema>;
1011
3564
  declare const TransactionPlanErrorSchema: z.ZodObject<{
1012
3565
  code: z.ZodString;
1013
3566
  message: z.ZodString;
1014
3567
  details: z.ZodRecord<z.ZodString, z.ZodString>;
1015
- }, z.core.$strip>;
3568
+ }, "strip", z.ZodTypeAny, {
3569
+ code: string;
3570
+ message: string;
3571
+ details: Record<string, string>;
3572
+ }, {
3573
+ code: string;
3574
+ message: string;
3575
+ details: Record<string, string>;
3576
+ }>;
1016
3577
  type TransactionPlanError = z.infer<typeof TransactionPlanErrorSchema>;
1017
3578
  declare const ProviderTrackingInfoSchema: z.ZodObject<{
1018
3579
  requestId: z.ZodString;
1019
3580
  providerName: z.ZodString;
1020
3581
  explorerUrl: z.ZodString;
1021
- }, z.core.$strip>;
3582
+ }, "strip", z.ZodTypeAny, {
3583
+ requestId: string;
3584
+ providerName: string;
3585
+ explorerUrl: string;
3586
+ }, {
3587
+ requestId: string;
3588
+ providerName: string;
3589
+ explorerUrl: string;
3590
+ }>;
1022
3591
  type ProviderTrackingInfo = z.infer<typeof ProviderTrackingInfoSchema>;
1023
3592
  declare const SwapEstimationSchema: z.ZodObject<{
1024
3593
  effectivePrice: z.ZodString;
1025
3594
  timeEstimate: z.ZodString;
1026
3595
  expiration: z.ZodString;
1027
- }, z.core.$strip>;
3596
+ }, "strip", z.ZodTypeAny, {
3597
+ effectivePrice: string;
3598
+ timeEstimate: string;
3599
+ expiration: string;
3600
+ }, {
3601
+ effectivePrice: string;
3602
+ timeEstimate: string;
3603
+ expiration: string;
3604
+ }>;
1028
3605
  type SwapEstimation = z.infer<typeof SwapEstimationSchema>;
1029
3606
  declare const ProviderTrackingStatusSchema: z.ZodObject<{
1030
3607
  requestId: z.ZodString;
@@ -1032,24 +3609,29 @@ declare const ProviderTrackingStatusSchema: z.ZodObject<{
1032
3609
  providerName: z.ZodString;
1033
3610
  explorerUrl: z.ZodString;
1034
3611
  status: z.ZodString;
1035
- }, z.core.$strip>;
3612
+ }, "strip", z.ZodTypeAny, {
3613
+ status: string;
3614
+ requestId: string;
3615
+ providerName: string;
3616
+ explorerUrl: string;
3617
+ transactionId: string;
3618
+ }, {
3619
+ status: string;
3620
+ requestId: string;
3621
+ providerName: string;
3622
+ explorerUrl: string;
3623
+ transactionId: string;
3624
+ }>;
1036
3625
  type ProviderTrackingStatus = z.infer<typeof ProviderTrackingStatusSchema>;
1037
3626
 
1038
- declare const ChainTypeSchema: z.ZodEnum<{
1039
- UNSPECIFIED: "UNSPECIFIED";
1040
- EVM: "EVM";
1041
- SOLANA: "SOLANA";
1042
- COSMOS: "COSMOS";
1043
- }>;
3627
+ declare const ChainTypeSchema: z.ZodEnum<["UNSPECIFIED", "EVM", "SOLANA", "COSMOS"]>;
1044
3628
  type ChainType = z.infer<typeof ChainTypeSchema>;
1045
3629
  declare const TransactionTypes: {
1046
3630
  readonly TRANSACTION_TYPE_UNSPECIFIED: "TRANSACTION_TYPE_UNSPECIFIED";
1047
3631
  readonly EVM_TX: "EVM_TX";
1048
3632
  readonly SOLANA_TX: "SOLANA_TX";
1049
3633
  };
1050
- declare const TransactionTypeSchema: z.ZodEnum<{
1051
- [x: string]: string;
1052
- }>;
3634
+ declare const TransactionTypeSchema: z.ZodEnum<[string, ...string[]]>;
1053
3635
  type TransactionType = keyof typeof TransactionTypes;
1054
3636
 
1055
3637
  interface EmberPlugin<Type extends PluginType> {