@lifi/compose-spec 0.15.0 → 0.15.2

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 (3) hide show
  1. package/dist/index.d.cts +240 -240
  2. package/dist/index.d.ts +240 -240
  3. package/package.json +11 -15
package/dist/index.d.cts CHANGED
@@ -29,19 +29,19 @@ export declare const ResourceSchema: Schema.transform<Schema.Union<[Schema.Struc
29
29
  token: Schema.refine<string, typeof Schema.String>;
30
30
  chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
31
31
  }>]>, Schema.SchemaClass<{
32
- readonly chainId: number;
33
32
  readonly kind: "native";
33
+ readonly chainId: number;
34
34
  } | {
35
+ readonly kind: "erc20";
35
36
  readonly token: string;
36
37
  readonly chainId: number;
37
- readonly kind: "erc20";
38
38
  }, {
39
- readonly chainId: number;
40
39
  readonly kind: "native";
40
+ readonly chainId: number;
41
41
  } | {
42
+ readonly kind: "erc20";
42
43
  readonly token: string;
43
44
  readonly chainId: number;
44
- readonly kind: "erc20";
45
45
  }, never>>;
46
46
  export declare const ResourceInputSchema: Schema.Struct<{
47
47
  name: typeof Schema.String;
@@ -53,19 +53,19 @@ export declare const ResourceInputSchema: Schema.Struct<{
53
53
  token: Schema.refine<string, typeof Schema.String>;
54
54
  chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
55
55
  }>]>, Schema.SchemaClass<{
56
- readonly chainId: number;
57
56
  readonly kind: "native";
57
+ readonly chainId: number;
58
58
  } | {
59
+ readonly kind: "erc20";
59
60
  readonly token: string;
60
61
  readonly chainId: number;
61
- readonly kind: "erc20";
62
62
  }, {
63
- readonly chainId: number;
64
63
  readonly kind: "native";
64
+ readonly chainId: number;
65
65
  } | {
66
+ readonly kind: "erc20";
66
67
  readonly token: string;
67
68
  readonly chainId: number;
68
- readonly kind: "erc20";
69
69
  }, never>>;
70
70
  }>;
71
71
  export declare const HandleInputSchema: Schema.Struct<{
@@ -82,19 +82,19 @@ export declare const FlowInputSchema: Schema.Union<[Schema.Struct<{
82
82
  token: Schema.refine<string, typeof Schema.String>;
83
83
  chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
84
84
  }>]>, Schema.SchemaClass<{
85
- readonly chainId: number;
86
85
  readonly kind: "native";
86
+ readonly chainId: number;
87
87
  } | {
88
+ readonly kind: "erc20";
88
89
  readonly token: string;
89
90
  readonly chainId: number;
90
- readonly kind: "erc20";
91
91
  }, {
92
- readonly chainId: number;
93
92
  readonly kind: "native";
93
+ readonly chainId: number;
94
94
  } | {
95
+ readonly kind: "erc20";
95
96
  readonly token: string;
96
97
  readonly chainId: number;
97
- readonly kind: "erc20";
98
98
  }, never>>;
99
99
  }>, Schema.Struct<{
100
100
  name: typeof Schema.String;
@@ -157,19 +157,19 @@ export declare const EpilogueForwardSchema: Schema.Struct<{
157
157
  token: Schema.refine<string, typeof Schema.String>;
158
158
  chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
159
159
  }>]>, Schema.SchemaClass<{
160
- readonly chainId: number;
161
160
  readonly kind: "native";
161
+ readonly chainId: number;
162
162
  } | {
163
+ readonly kind: "erc20";
163
164
  readonly token: string;
164
165
  readonly chainId: number;
165
- readonly kind: "erc20";
166
166
  }, {
167
- readonly chainId: number;
168
167
  readonly kind: "native";
168
+ readonly chainId: number;
169
169
  } | {
170
+ readonly kind: "erc20";
170
171
  readonly token: string;
171
172
  readonly chainId: number;
172
- readonly kind: "erc20";
173
173
  }, never>>;
174
174
  to: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Struct<{
175
175
  $ref: Schema.filter<typeof Schema.String>;
@@ -185,19 +185,19 @@ export declare const EpilogueSchema: Schema.filter<Schema.Struct<{
185
185
  token: Schema.refine<string, typeof Schema.String>;
186
186
  chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
187
187
  }>]>, Schema.SchemaClass<{
188
- readonly chainId: number;
189
188
  readonly kind: "native";
189
+ readonly chainId: number;
190
190
  } | {
191
+ readonly kind: "erc20";
191
192
  readonly token: string;
192
193
  readonly chainId: number;
193
- readonly kind: "erc20";
194
194
  }, {
195
- readonly chainId: number;
196
195
  readonly kind: "native";
196
+ readonly chainId: number;
197
197
  } | {
198
+ readonly kind: "erc20";
198
199
  readonly token: string;
199
200
  readonly chainId: number;
200
- readonly kind: "erc20";
201
201
  }, never>>;
202
202
  to: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Struct<{
203
203
  $ref: Schema.filter<typeof Schema.String>;
@@ -221,19 +221,19 @@ export declare const FlowSchema: Schema.Struct<{
221
221
  token: Schema.refine<string, typeof Schema.String>;
222
222
  chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
223
223
  }>]>, Schema.SchemaClass<{
224
- readonly chainId: number;
225
224
  readonly kind: "native";
225
+ readonly chainId: number;
226
226
  } | {
227
+ readonly kind: "erc20";
227
228
  readonly token: string;
228
229
  readonly chainId: number;
229
- readonly kind: "erc20";
230
230
  }, {
231
- readonly chainId: number;
232
231
  readonly kind: "native";
232
+ readonly chainId: number;
233
233
  } | {
234
+ readonly kind: "erc20";
234
235
  readonly token: string;
235
236
  readonly chainId: number;
236
- readonly kind: "erc20";
237
237
  }, never>>;
238
238
  }>, Schema.Struct<{
239
239
  name: typeof Schema.String;
@@ -274,19 +274,19 @@ export declare const FlowSchema: Schema.Struct<{
274
274
  token: Schema.refine<string, typeof Schema.String>;
275
275
  chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
276
276
  }>]>, Schema.SchemaClass<{
277
- readonly chainId: number;
278
277
  readonly kind: "native";
278
+ readonly chainId: number;
279
279
  } | {
280
+ readonly kind: "erc20";
280
281
  readonly token: string;
281
282
  readonly chainId: number;
282
- readonly kind: "erc20";
283
283
  }, {
284
- readonly chainId: number;
285
284
  readonly kind: "native";
285
+ readonly chainId: number;
286
286
  } | {
287
+ readonly kind: "erc20";
287
288
  readonly token: string;
288
289
  readonly chainId: number;
289
- readonly kind: "erc20";
290
290
  }, never>>;
291
291
  to: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Struct<{
292
292
  $ref: Schema.filter<typeof Schema.String>;
@@ -320,10 +320,10 @@ export declare const ContinuationOutcomeSchema: Schema.transform<Schema.Schema<{
320
320
  readonly destination: string;
321
321
  readonly chainId: number;
322
322
  }, {
323
- readonly token: string;
324
- readonly destination: string;
325
323
  readonly chainId: number;
324
+ readonly destination: string;
326
325
  readonly minAmount?: string | undefined;
326
+ readonly token: string;
327
327
  }, never>, Schema.SchemaClass<{
328
328
  readonly token: string;
329
329
  readonly minAmount?: string | undefined;
@@ -341,10 +341,10 @@ export declare const CommittedOutcomeSchema: Schema.transform<Schema.Schema<{
341
341
  readonly destination: string;
342
342
  readonly chainId: number;
343
343
  }, {
344
- readonly token: string;
345
- readonly minAmount: string;
346
- readonly destination: string;
347
344
  readonly chainId: number;
345
+ readonly destination: string;
346
+ readonly minAmount: string;
347
+ readonly token: string;
348
348
  }, never>, Schema.SchemaClass<{
349
349
  readonly token: string;
350
350
  readonly minAmount: string;
@@ -363,10 +363,10 @@ export declare const ContinuationIntentSchema: Schema.Struct<{
363
363
  readonly destination: string;
364
364
  readonly chainId: number;
365
365
  }, {
366
- readonly token: string;
367
- readonly destination: string;
368
366
  readonly chainId: number;
367
+ readonly destination: string;
369
368
  readonly minAmount?: string | undefined;
369
+ readonly token: string;
370
370
  }, never>, Schema.SchemaClass<{
371
371
  readonly token: string;
372
372
  readonly minAmount?: string | undefined;
@@ -392,19 +392,19 @@ export declare const ContinuationIntentSchema: Schema.Struct<{
392
392
  token: Schema.refine<string, typeof Schema.String>;
393
393
  chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
394
394
  }>]>, Schema.SchemaClass<{
395
- readonly chainId: number;
396
395
  readonly kind: "native";
396
+ readonly chainId: number;
397
397
  } | {
398
+ readonly kind: "erc20";
398
399
  readonly token: string;
399
400
  readonly chainId: number;
400
- readonly kind: "erc20";
401
401
  }, {
402
- readonly chainId: number;
403
402
  readonly kind: "native";
403
+ readonly chainId: number;
404
404
  } | {
405
+ readonly kind: "erc20";
405
406
  readonly token: string;
406
407
  readonly chainId: number;
407
- readonly kind: "erc20";
408
408
  }, never>>;
409
409
  }>, Schema.Struct<{
410
410
  name: typeof Schema.String;
@@ -445,19 +445,19 @@ export declare const ContinuationIntentSchema: Schema.Struct<{
445
445
  token: Schema.refine<string, typeof Schema.String>;
446
446
  chainId: Schema.filter<Schema.filter<typeof Schema.Number>>;
447
447
  }>]>, Schema.SchemaClass<{
448
- readonly chainId: number;
449
448
  readonly kind: "native";
449
+ readonly chainId: number;
450
450
  } | {
451
+ readonly kind: "erc20";
451
452
  readonly token: string;
452
453
  readonly chainId: number;
453
- readonly kind: "erc20";
454
454
  }, {
455
- readonly chainId: number;
456
455
  readonly kind: "native";
456
+ readonly chainId: number;
457
457
  } | {
458
+ readonly kind: "erc20";
458
459
  readonly token: string;
459
460
  readonly chainId: number;
460
- readonly kind: "erc20";
461
461
  }, never>>;
462
462
  to: Schema.Union<[Schema.refine<string, typeof Schema.String>, Schema.Struct<{
463
463
  $ref: Schema.filter<typeof Schema.String>;
@@ -565,7 +565,7 @@ type AssertionSpec = typeof AssertionSpecSchema.Type;
565
565
  type CallCheckSpec = typeof CallCheckSpecSchema.Type;
566
566
  export declare const settledOutcome: <I extends {
567
567
  readonly outcomes: readonly unknown[];
568
- }>(intent: I) => I["outcomes"][number] | undefined;
568
+ }>(intent: I) => I['outcomes'][number] | undefined;
569
569
  //#endregion
570
570
  //#region src/descriptor.d.ts
571
571
  export declare const Bytes32HexSchema: Schema.filter<typeof Schema.String>;
@@ -589,42 +589,42 @@ export declare const AssertedPredicateSchema: Schema.transformOrFail<Schema.Unio
589
589
  comparator: Schema.Literal<["gte", "eq", "lte"]>;
590
590
  threshold: Schema.filter<typeof Schema.String>;
591
591
  }>]>, Schema.SchemaClass<{
592
- readonly minAmount: string;
592
+ readonly kind: "erc20BalanceGte";
593
593
  readonly chainId: number;
594
- readonly kind: "nativeBalanceGte";
595
- readonly owner: string;
596
- } | {
597
594
  readonly token: string;
595
+ readonly owner: string;
598
596
  readonly minAmount: string;
597
+ } | {
598
+ readonly kind: "nativeBalanceGte";
599
599
  readonly chainId: number;
600
- readonly kind: "erc20BalanceGte";
601
600
  readonly owner: string;
601
+ readonly minAmount: string;
602
602
  } | {
603
- readonly chainId: number;
604
603
  readonly kind: "call";
604
+ readonly chainId: number;
605
605
  readonly to: string;
606
606
  readonly signature: string;
607
607
  readonly args: readonly string[];
608
- readonly comparator: "gte" | "eq" | "lte";
608
+ readonly comparator: "eq" | "gte" | "lte";
609
609
  readonly threshold: string;
610
610
  }, {
611
- readonly minAmount: string;
611
+ readonly kind: "erc20BalanceGte";
612
612
  readonly chainId: number;
613
- readonly kind: "nativeBalanceGte";
614
- readonly owner: string;
615
- } | {
616
613
  readonly token: string;
614
+ readonly owner: string;
617
615
  readonly minAmount: string;
616
+ } | {
617
+ readonly kind: "nativeBalanceGte";
618
618
  readonly chainId: number;
619
- readonly kind: "erc20BalanceGte";
620
619
  readonly owner: string;
620
+ readonly minAmount: string;
621
621
  } | {
622
- readonly chainId: number;
623
622
  readonly kind: "call";
623
+ readonly chainId: number;
624
624
  readonly to: string;
625
625
  readonly signature: string;
626
626
  readonly args: readonly string[];
627
- readonly comparator: "gte" | "eq" | "lte";
627
+ readonly comparator: "eq" | "gte" | "lte";
628
628
  readonly threshold: string;
629
629
  }, never>, never>;
630
630
  export declare const VerificationDescriptorSchema: Schema.Struct<{
@@ -650,42 +650,42 @@ export declare const VerificationDescriptorSchema: Schema.Struct<{
650
650
  comparator: Schema.Literal<["gte", "eq", "lte"]>;
651
651
  threshold: Schema.filter<typeof Schema.String>;
652
652
  }>]>, Schema.SchemaClass<{
653
- readonly minAmount: string;
653
+ readonly kind: "erc20BalanceGte";
654
654
  readonly chainId: number;
655
- readonly kind: "nativeBalanceGte";
656
- readonly owner: string;
657
- } | {
658
655
  readonly token: string;
656
+ readonly owner: string;
659
657
  readonly minAmount: string;
658
+ } | {
659
+ readonly kind: "nativeBalanceGte";
660
660
  readonly chainId: number;
661
- readonly kind: "erc20BalanceGte";
662
661
  readonly owner: string;
662
+ readonly minAmount: string;
663
663
  } | {
664
- readonly chainId: number;
665
664
  readonly kind: "call";
665
+ readonly chainId: number;
666
666
  readonly to: string;
667
667
  readonly signature: string;
668
668
  readonly args: readonly string[];
669
- readonly comparator: "gte" | "eq" | "lte";
669
+ readonly comparator: "eq" | "gte" | "lte";
670
670
  readonly threshold: string;
671
671
  }, {
672
- readonly minAmount: string;
672
+ readonly kind: "erc20BalanceGte";
673
673
  readonly chainId: number;
674
- readonly kind: "nativeBalanceGte";
675
- readonly owner: string;
676
- } | {
677
674
  readonly token: string;
675
+ readonly owner: string;
678
676
  readonly minAmount: string;
677
+ } | {
678
+ readonly kind: "nativeBalanceGte";
679
679
  readonly chainId: number;
680
- readonly kind: "erc20BalanceGte";
681
680
  readonly owner: string;
681
+ readonly minAmount: string;
682
682
  } | {
683
- readonly chainId: number;
684
683
  readonly kind: "call";
684
+ readonly chainId: number;
685
685
  readonly to: string;
686
686
  readonly signature: string;
687
687
  readonly args: readonly string[];
688
- readonly comparator: "gte" | "eq" | "lte";
688
+ readonly comparator: "eq" | "gte" | "lte";
689
689
  readonly threshold: string;
690
690
  }, never>, never>>;
691
691
  }>;
@@ -766,67 +766,67 @@ export declare const ResourcePortZod: z.ZodObject<{
766
766
  kind: z.ZodLiteral<"resource">;
767
767
  name: z.ZodString;
768
768
  accepts: z.ZodEnum<{
769
- native: "native";
770
- erc20: "erc20";
771
769
  any: "any";
770
+ erc20: "erc20";
771
+ native: "native";
772
772
  }>;
773
773
  mode: z.ZodEnum<{
774
- linear: "linear";
775
774
  copy: "copy";
775
+ linear: "linear";
776
776
  }>;
777
777
  optional: z.ZodOptional<z.ZodBoolean>;
778
778
  }, z.core.$strip>;
779
- export declare const HANDLE_UNITS: readonly ["raw", "wad", "ray", "bps", "token-decimals"];
780
- export declare const STATIC_SOL_TYPES: readonly ["uint256", "uint128", "uint64", "uint32", "uint16", "uint8", "address", "bool", "bytes32"];
779
+ export declare const HANDLE_UNITS: readonly ['raw', 'wad', 'ray', 'bps', 'token-decimals'];
780
+ export declare const STATIC_SOL_TYPES: readonly ['uint256', 'uint128', 'uint64', 'uint32', 'uint16', 'uint8', 'address', 'bool', 'bytes32'];
781
781
  export declare const HandleUnitsZod: z.ZodEnum<{
782
+ bps: "bps";
782
783
  raw: "raw";
783
- wad: "wad";
784
784
  ray: "ray";
785
- bps: "bps";
786
785
  "token-decimals": "token-decimals";
786
+ wad: "wad";
787
787
  }>;
788
788
  export declare const StaticSolTypeZod: z.ZodEnum<{
789
- uint8: "uint8";
790
- uint16: "uint16";
791
- uint32: "uint32";
792
- uint64: "uint64";
793
- uint128: "uint128";
794
- uint256: "uint256";
795
789
  address: "address";
796
790
  bool: "bool";
797
791
  bytes32: "bytes32";
792
+ uint128: "uint128";
793
+ uint16: "uint16";
794
+ uint256: "uint256";
795
+ uint32: "uint32";
796
+ uint64: "uint64";
797
+ uint8: "uint8";
798
798
  }>;
799
799
  export declare const isStaticSolType: (value: string) => value is StaticSolType;
800
800
  export declare const HandlePortZod: z.ZodObject<{
801
801
  kind: z.ZodLiteral<"handle">;
802
802
  name: z.ZodString;
803
803
  type: z.ZodEnum<{
804
- string: "string";
805
- uint8: "uint8";
806
- uint16: "uint16";
807
- uint32: "uint32";
808
- uint64: "uint64";
809
- uint128: "uint128";
810
- uint256: "uint256";
811
- int128: "int128";
812
- int256: "int256";
813
804
  address: "address";
814
805
  bool: "bool";
815
806
  bytes: "bytes";
816
- bytes4: "bytes4";
817
807
  bytes32: "bytes32";
808
+ bytes4: "bytes4";
809
+ int128: "int128";
810
+ int256: "int256";
811
+ string: "string";
812
+ uint128: "uint128";
813
+ uint16: "uint16";
814
+ uint256: "uint256";
815
+ uint32: "uint32";
816
+ uint64: "uint64";
817
+ uint8: "uint8";
818
818
  }>;
819
819
  mode: z.ZodEnum<{
820
- linear: "linear";
821
820
  copy: "copy";
821
+ linear: "linear";
822
822
  }>;
823
823
  expose: z.ZodOptional<z.ZodBoolean>;
824
824
  units: z.ZodOptional<z.ZodEnum<{
825
+ bps: "bps";
825
826
  raw: "raw";
826
- wad: "wad";
827
827
  ray: "ray";
828
- bps: "bps";
829
828
  "token-decimals": "token-decimals";
829
+ wad: "wad";
830
830
  }>>;
831
831
  optional: z.ZodOptional<z.ZodBoolean>;
832
832
  }, z.core.$strip>;
@@ -834,45 +834,45 @@ export declare const InputPortZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
834
834
  kind: z.ZodLiteral<"resource">;
835
835
  name: z.ZodString;
836
836
  accepts: z.ZodEnum<{
837
- native: "native";
838
- erc20: "erc20";
839
837
  any: "any";
838
+ erc20: "erc20";
839
+ native: "native";
840
840
  }>;
841
841
  mode: z.ZodEnum<{
842
- linear: "linear";
843
842
  copy: "copy";
843
+ linear: "linear";
844
844
  }>;
845
845
  optional: z.ZodOptional<z.ZodBoolean>;
846
846
  }, z.core.$strip>, z.ZodObject<{
847
847
  kind: z.ZodLiteral<"handle">;
848
848
  name: z.ZodString;
849
849
  type: z.ZodEnum<{
850
- string: "string";
851
- uint8: "uint8";
852
- uint16: "uint16";
853
- uint32: "uint32";
854
- uint64: "uint64";
855
- uint128: "uint128";
856
- uint256: "uint256";
857
- int128: "int128";
858
- int256: "int256";
859
850
  address: "address";
860
851
  bool: "bool";
861
852
  bytes: "bytes";
862
- bytes4: "bytes4";
863
853
  bytes32: "bytes32";
854
+ bytes4: "bytes4";
855
+ int128: "int128";
856
+ int256: "int256";
857
+ string: "string";
858
+ uint128: "uint128";
859
+ uint16: "uint16";
860
+ uint256: "uint256";
861
+ uint32: "uint32";
862
+ uint64: "uint64";
863
+ uint8: "uint8";
864
864
  }>;
865
865
  mode: z.ZodEnum<{
866
- linear: "linear";
867
866
  copy: "copy";
867
+ linear: "linear";
868
868
  }>;
869
869
  expose: z.ZodOptional<z.ZodBoolean>;
870
870
  units: z.ZodOptional<z.ZodEnum<{
871
+ bps: "bps";
871
872
  raw: "raw";
872
- wad: "wad";
873
873
  ray: "ray";
874
- bps: "bps";
875
874
  "token-decimals": "token-decimals";
875
+ wad: "wad";
876
876
  }>>;
877
877
  optional: z.ZodOptional<z.ZodBoolean>;
878
878
  }, z.core.$strip>], "kind">;
@@ -880,12 +880,12 @@ export declare const ResourceOutputPortZod: z.ZodObject<{
880
880
  kind: z.ZodLiteral<"resource_output">;
881
881
  name: z.ZodString;
882
882
  mode: z.ZodEnum<{
883
- linear: "linear";
884
883
  copy: "copy";
884
+ linear: "linear";
885
885
  }>;
886
886
  availability: z.ZodOptional<z.ZodEnum<{
887
- now: "now";
888
887
  future: "future";
888
+ now: "now";
889
889
  }>>;
890
890
  providesMinimum: z.ZodOptional<z.ZodBoolean>;
891
891
  omitIfZero: z.ZodOptional<z.ZodBoolean>;
@@ -896,12 +896,12 @@ export declare const OutputPortZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
896
896
  kind: z.ZodLiteral<"resource_output">;
897
897
  name: z.ZodString;
898
898
  mode: z.ZodEnum<{
899
- linear: "linear";
900
899
  copy: "copy";
900
+ linear: "linear";
901
901
  }>;
902
902
  availability: z.ZodOptional<z.ZodEnum<{
903
- now: "now";
904
903
  future: "future";
904
+ now: "now";
905
905
  }>>;
906
906
  providesMinimum: z.ZodOptional<z.ZodBoolean>;
907
907
  omitIfZero: z.ZodOptional<z.ZodBoolean>;
@@ -911,32 +911,32 @@ export declare const OutputPortZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
911
911
  kind: z.ZodLiteral<"handle">;
912
912
  name: z.ZodString;
913
913
  type: z.ZodEnum<{
914
- string: "string";
915
- uint8: "uint8";
916
- uint16: "uint16";
917
- uint32: "uint32";
918
- uint64: "uint64";
919
- uint128: "uint128";
920
- uint256: "uint256";
921
- int128: "int128";
922
- int256: "int256";
923
914
  address: "address";
924
915
  bool: "bool";
925
916
  bytes: "bytes";
926
- bytes4: "bytes4";
927
917
  bytes32: "bytes32";
918
+ bytes4: "bytes4";
919
+ int128: "int128";
920
+ int256: "int256";
921
+ string: "string";
922
+ uint128: "uint128";
923
+ uint16: "uint16";
924
+ uint256: "uint256";
925
+ uint32: "uint32";
926
+ uint64: "uint64";
927
+ uint8: "uint8";
928
928
  }>;
929
929
  mode: z.ZodEnum<{
930
- linear: "linear";
931
930
  copy: "copy";
931
+ linear: "linear";
932
932
  }>;
933
933
  expose: z.ZodOptional<z.ZodBoolean>;
934
934
  units: z.ZodOptional<z.ZodEnum<{
935
+ bps: "bps";
935
936
  raw: "raw";
936
- wad: "wad";
937
937
  ray: "ray";
938
- bps: "bps";
939
938
  "token-decimals": "token-decimals";
939
+ wad: "wad";
940
940
  }>>;
941
941
  optional: z.ZodOptional<z.ZodBoolean>;
942
942
  }, z.core.$strip>], "kind">;
@@ -947,45 +947,45 @@ export declare const ManifestOperationZod: z.ZodObject<{
947
947
  kind: z.ZodLiteral<"resource">;
948
948
  name: z.ZodString;
949
949
  accepts: z.ZodEnum<{
950
- native: "native";
951
- erc20: "erc20";
952
950
  any: "any";
951
+ erc20: "erc20";
952
+ native: "native";
953
953
  }>;
954
954
  mode: z.ZodEnum<{
955
- linear: "linear";
956
955
  copy: "copy";
956
+ linear: "linear";
957
957
  }>;
958
958
  optional: z.ZodOptional<z.ZodBoolean>;
959
959
  }, z.core.$strip>, z.ZodObject<{
960
960
  kind: z.ZodLiteral<"handle">;
961
961
  name: z.ZodString;
962
962
  type: z.ZodEnum<{
963
- string: "string";
964
- uint8: "uint8";
965
- uint16: "uint16";
966
- uint32: "uint32";
967
- uint64: "uint64";
968
- uint128: "uint128";
969
- uint256: "uint256";
970
- int128: "int128";
971
- int256: "int256";
972
963
  address: "address";
973
964
  bool: "bool";
974
965
  bytes: "bytes";
975
- bytes4: "bytes4";
976
966
  bytes32: "bytes32";
967
+ bytes4: "bytes4";
968
+ int128: "int128";
969
+ int256: "int256";
970
+ string: "string";
971
+ uint128: "uint128";
972
+ uint16: "uint16";
973
+ uint256: "uint256";
974
+ uint32: "uint32";
975
+ uint64: "uint64";
976
+ uint8: "uint8";
977
977
  }>;
978
978
  mode: z.ZodEnum<{
979
- linear: "linear";
980
979
  copy: "copy";
980
+ linear: "linear";
981
981
  }>;
982
982
  expose: z.ZodOptional<z.ZodBoolean>;
983
983
  units: z.ZodOptional<z.ZodEnum<{
984
+ bps: "bps";
984
985
  raw: "raw";
985
- wad: "wad";
986
986
  ray: "ray";
987
- bps: "bps";
988
987
  "token-decimals": "token-decimals";
988
+ wad: "wad";
989
989
  }>>;
990
990
  optional: z.ZodOptional<z.ZodBoolean>;
991
991
  }, z.core.$strip>], "kind">>;
@@ -993,12 +993,12 @@ export declare const ManifestOperationZod: z.ZodObject<{
993
993
  kind: z.ZodLiteral<"resource_output">;
994
994
  name: z.ZodString;
995
995
  mode: z.ZodEnum<{
996
- linear: "linear";
997
996
  copy: "copy";
997
+ linear: "linear";
998
998
  }>;
999
999
  availability: z.ZodOptional<z.ZodEnum<{
1000
- now: "now";
1001
1000
  future: "future";
1001
+ now: "now";
1002
1002
  }>>;
1003
1003
  providesMinimum: z.ZodOptional<z.ZodBoolean>;
1004
1004
  omitIfZero: z.ZodOptional<z.ZodBoolean>;
@@ -1008,32 +1008,32 @@ export declare const ManifestOperationZod: z.ZodObject<{
1008
1008
  kind: z.ZodLiteral<"handle">;
1009
1009
  name: z.ZodString;
1010
1010
  type: z.ZodEnum<{
1011
- string: "string";
1012
- uint8: "uint8";
1013
- uint16: "uint16";
1014
- uint32: "uint32";
1015
- uint64: "uint64";
1016
- uint128: "uint128";
1017
- uint256: "uint256";
1018
- int128: "int128";
1019
- int256: "int256";
1020
1011
  address: "address";
1021
1012
  bool: "bool";
1022
1013
  bytes: "bytes";
1023
- bytes4: "bytes4";
1024
1014
  bytes32: "bytes32";
1015
+ bytes4: "bytes4";
1016
+ int128: "int128";
1017
+ int256: "int256";
1018
+ string: "string";
1019
+ uint128: "uint128";
1020
+ uint16: "uint16";
1021
+ uint256: "uint256";
1022
+ uint32: "uint32";
1023
+ uint64: "uint64";
1024
+ uint8: "uint8";
1025
1025
  }>;
1026
1026
  mode: z.ZodEnum<{
1027
- linear: "linear";
1028
1027
  copy: "copy";
1028
+ linear: "linear";
1029
1029
  }>;
1030
1030
  expose: z.ZodOptional<z.ZodBoolean>;
1031
1031
  units: z.ZodOptional<z.ZodEnum<{
1032
+ bps: "bps";
1032
1033
  raw: "raw";
1033
- wad: "wad";
1034
1034
  ray: "ray";
1035
- bps: "bps";
1036
1035
  "token-decimals": "token-decimals";
1036
+ wad: "wad";
1037
1037
  }>>;
1038
1038
  optional: z.ZodOptional<z.ZodBoolean>;
1039
1039
  }, z.core.$strip>], "kind">>;
@@ -1047,30 +1047,30 @@ export declare const GuardSelectorZod: z.ZodObject<{
1047
1047
  }>;
1048
1048
  match: z.ZodObject<{
1049
1049
  kind: z.ZodUnion<readonly [z.ZodEnum<{
1050
- resource: "resource";
1051
1050
  handle: "handle";
1051
+ resource: "resource";
1052
1052
  resource_output: "resource_output";
1053
1053
  }>, z.ZodArray<z.ZodEnum<{
1054
- resource: "resource";
1055
1054
  handle: "handle";
1055
+ resource: "resource";
1056
1056
  resource_output: "resource_output";
1057
1057
  }>>]>;
1058
1058
  mode: z.ZodOptional<z.ZodEnum<{
1059
- linear: "linear";
1060
1059
  copy: "copy";
1060
+ linear: "linear";
1061
1061
  }>>;
1062
1062
  type: z.ZodOptional<z.ZodEnum<{
1063
- native: "native";
1064
- erc20: "erc20";
1065
1063
  any: "any";
1064
+ erc20: "erc20";
1065
+ native: "native";
1066
1066
  }>>;
1067
1067
  }, z.core.$strip>;
1068
1068
  selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
1069
1069
  kind: z.ZodLiteral<"config">;
1070
1070
  configKey: z.ZodString;
1071
1071
  cardinality: z.ZodEnum<{
1072
- one: "one";
1073
1072
  many: "many";
1073
+ one: "one";
1074
1074
  }>;
1075
1075
  }, z.core.$strip>, z.ZodObject<{
1076
1076
  kind: z.ZodLiteral<"all_matching">;
@@ -1085,30 +1085,30 @@ export declare const GuardCompatibilityZod: z.ZodObject<{
1085
1085
  }>;
1086
1086
  match: z.ZodObject<{
1087
1087
  kind: z.ZodUnion<readonly [z.ZodEnum<{
1088
- resource: "resource";
1089
1088
  handle: "handle";
1089
+ resource: "resource";
1090
1090
  resource_output: "resource_output";
1091
1091
  }>, z.ZodArray<z.ZodEnum<{
1092
- resource: "resource";
1093
1092
  handle: "handle";
1093
+ resource: "resource";
1094
1094
  resource_output: "resource_output";
1095
1095
  }>>]>;
1096
1096
  mode: z.ZodOptional<z.ZodEnum<{
1097
- linear: "linear";
1098
1097
  copy: "copy";
1098
+ linear: "linear";
1099
1099
  }>>;
1100
1100
  type: z.ZodOptional<z.ZodEnum<{
1101
- native: "native";
1102
- erc20: "erc20";
1103
1101
  any: "any";
1102
+ erc20: "erc20";
1103
+ native: "native";
1104
1104
  }>>;
1105
1105
  }, z.core.$strip>;
1106
1106
  selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
1107
1107
  kind: z.ZodLiteral<"config">;
1108
1108
  configKey: z.ZodString;
1109
1109
  cardinality: z.ZodEnum<{
1110
- one: "one";
1111
1110
  many: "many";
1111
+ one: "one";
1112
1112
  }>;
1113
1113
  }, z.core.$strip>, z.ZodObject<{
1114
1114
  kind: z.ZodLiteral<"all_matching">;
@@ -1128,30 +1128,30 @@ export declare const ManifestGuardZod: z.ZodObject<{
1128
1128
  }>;
1129
1129
  match: z.ZodObject<{
1130
1130
  kind: z.ZodUnion<readonly [z.ZodEnum<{
1131
- resource: "resource";
1132
1131
  handle: "handle";
1132
+ resource: "resource";
1133
1133
  resource_output: "resource_output";
1134
1134
  }>, z.ZodArray<z.ZodEnum<{
1135
- resource: "resource";
1136
1135
  handle: "handle";
1136
+ resource: "resource";
1137
1137
  resource_output: "resource_output";
1138
1138
  }>>]>;
1139
1139
  mode: z.ZodOptional<z.ZodEnum<{
1140
- linear: "linear";
1141
1140
  copy: "copy";
1141
+ linear: "linear";
1142
1142
  }>>;
1143
1143
  type: z.ZodOptional<z.ZodEnum<{
1144
- native: "native";
1145
- erc20: "erc20";
1146
1144
  any: "any";
1145
+ erc20: "erc20";
1146
+ native: "native";
1147
1147
  }>>;
1148
1148
  }, z.core.$strip>;
1149
1149
  selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
1150
1150
  kind: z.ZodLiteral<"config">;
1151
1151
  configKey: z.ZodString;
1152
1152
  cardinality: z.ZodEnum<{
1153
- one: "one";
1154
1153
  many: "many";
1154
+ one: "one";
1155
1155
  }>;
1156
1156
  }, z.core.$strip>, z.ZodObject<{
1157
1157
  kind: z.ZodLiteral<"all_matching">;
@@ -1163,9 +1163,9 @@ export declare const ManifestMaterialiserZod: z.ZodObject<{
1163
1163
  kind: z.ZodString;
1164
1164
  description: z.ZodOptional<z.ZodString>;
1165
1165
  accepts: z.ZodEnum<{
1166
- resource: "resource";
1167
1166
  any: "any";
1168
1167
  handle: "handle";
1168
+ resource: "resource";
1169
1169
  }>;
1170
1170
  configSchema: z.ZodOptional<z.ZodUnknown>;
1171
1171
  }, z.core.$strip>;
@@ -1177,8 +1177,8 @@ export declare const ManifestPreconditionZod: z.ZodObject<{
1177
1177
  export declare const ManifestRoutingZod: z.ZodObject<{
1178
1178
  maxRouteHops: z.ZodNumber;
1179
1179
  swapHops: z.ZodEnum<{
1180
- none: "none";
1181
1180
  head: "head";
1181
+ none: "none";
1182
1182
  }>;
1183
1183
  }, z.core.$strip>;
1184
1184
  export declare const ComposeManifestZod: z.ZodObject<{
@@ -1192,45 +1192,45 @@ export declare const ComposeManifestZod: z.ZodObject<{
1192
1192
  kind: z.ZodLiteral<"resource">;
1193
1193
  name: z.ZodString;
1194
1194
  accepts: z.ZodEnum<{
1195
- native: "native";
1196
- erc20: "erc20";
1197
1195
  any: "any";
1196
+ erc20: "erc20";
1197
+ native: "native";
1198
1198
  }>;
1199
1199
  mode: z.ZodEnum<{
1200
- linear: "linear";
1201
1200
  copy: "copy";
1201
+ linear: "linear";
1202
1202
  }>;
1203
1203
  optional: z.ZodOptional<z.ZodBoolean>;
1204
1204
  }, z.core.$strip>, z.ZodObject<{
1205
1205
  kind: z.ZodLiteral<"handle">;
1206
1206
  name: z.ZodString;
1207
1207
  type: z.ZodEnum<{
1208
- string: "string";
1209
- uint8: "uint8";
1210
- uint16: "uint16";
1211
- uint32: "uint32";
1212
- uint64: "uint64";
1213
- uint128: "uint128";
1214
- uint256: "uint256";
1215
- int128: "int128";
1216
- int256: "int256";
1217
1208
  address: "address";
1218
1209
  bool: "bool";
1219
1210
  bytes: "bytes";
1220
- bytes4: "bytes4";
1221
1211
  bytes32: "bytes32";
1212
+ bytes4: "bytes4";
1213
+ int128: "int128";
1214
+ int256: "int256";
1215
+ string: "string";
1216
+ uint128: "uint128";
1217
+ uint16: "uint16";
1218
+ uint256: "uint256";
1219
+ uint32: "uint32";
1220
+ uint64: "uint64";
1221
+ uint8: "uint8";
1222
1222
  }>;
1223
1223
  mode: z.ZodEnum<{
1224
- linear: "linear";
1225
1224
  copy: "copy";
1225
+ linear: "linear";
1226
1226
  }>;
1227
1227
  expose: z.ZodOptional<z.ZodBoolean>;
1228
1228
  units: z.ZodOptional<z.ZodEnum<{
1229
+ bps: "bps";
1229
1230
  raw: "raw";
1230
- wad: "wad";
1231
1231
  ray: "ray";
1232
- bps: "bps";
1233
1232
  "token-decimals": "token-decimals";
1233
+ wad: "wad";
1234
1234
  }>>;
1235
1235
  optional: z.ZodOptional<z.ZodBoolean>;
1236
1236
  }, z.core.$strip>], "kind">>;
@@ -1238,12 +1238,12 @@ export declare const ComposeManifestZod: z.ZodObject<{
1238
1238
  kind: z.ZodLiteral<"resource_output">;
1239
1239
  name: z.ZodString;
1240
1240
  mode: z.ZodEnum<{
1241
- linear: "linear";
1242
1241
  copy: "copy";
1242
+ linear: "linear";
1243
1243
  }>;
1244
1244
  availability: z.ZodOptional<z.ZodEnum<{
1245
- now: "now";
1246
1245
  future: "future";
1246
+ now: "now";
1247
1247
  }>>;
1248
1248
  providesMinimum: z.ZodOptional<z.ZodBoolean>;
1249
1249
  omitIfZero: z.ZodOptional<z.ZodBoolean>;
@@ -1253,32 +1253,32 @@ export declare const ComposeManifestZod: z.ZodObject<{
1253
1253
  kind: z.ZodLiteral<"handle">;
1254
1254
  name: z.ZodString;
1255
1255
  type: z.ZodEnum<{
1256
- string: "string";
1257
- uint8: "uint8";
1258
- uint16: "uint16";
1259
- uint32: "uint32";
1260
- uint64: "uint64";
1261
- uint128: "uint128";
1262
- uint256: "uint256";
1263
- int128: "int128";
1264
- int256: "int256";
1265
1256
  address: "address";
1266
1257
  bool: "bool";
1267
1258
  bytes: "bytes";
1268
- bytes4: "bytes4";
1269
1259
  bytes32: "bytes32";
1260
+ bytes4: "bytes4";
1261
+ int128: "int128";
1262
+ int256: "int256";
1263
+ string: "string";
1264
+ uint128: "uint128";
1265
+ uint16: "uint16";
1266
+ uint256: "uint256";
1267
+ uint32: "uint32";
1268
+ uint64: "uint64";
1269
+ uint8: "uint8";
1270
1270
  }>;
1271
1271
  mode: z.ZodEnum<{
1272
- linear: "linear";
1273
1272
  copy: "copy";
1273
+ linear: "linear";
1274
1274
  }>;
1275
1275
  expose: z.ZodOptional<z.ZodBoolean>;
1276
1276
  units: z.ZodOptional<z.ZodEnum<{
1277
+ bps: "bps";
1277
1278
  raw: "raw";
1278
- wad: "wad";
1279
1279
  ray: "ray";
1280
- bps: "bps";
1281
1280
  "token-decimals": "token-decimals";
1281
+ wad: "wad";
1282
1282
  }>>;
1283
1283
  optional: z.ZodOptional<z.ZodBoolean>;
1284
1284
  }, z.core.$strip>], "kind">>;
@@ -1297,30 +1297,30 @@ export declare const ComposeManifestZod: z.ZodObject<{
1297
1297
  }>;
1298
1298
  match: z.ZodObject<{
1299
1299
  kind: z.ZodUnion<readonly [z.ZodEnum<{
1300
- resource: "resource";
1301
1300
  handle: "handle";
1301
+ resource: "resource";
1302
1302
  resource_output: "resource_output";
1303
1303
  }>, z.ZodArray<z.ZodEnum<{
1304
- resource: "resource";
1305
1304
  handle: "handle";
1305
+ resource: "resource";
1306
1306
  resource_output: "resource_output";
1307
1307
  }>>]>;
1308
1308
  mode: z.ZodOptional<z.ZodEnum<{
1309
- linear: "linear";
1310
1309
  copy: "copy";
1310
+ linear: "linear";
1311
1311
  }>>;
1312
1312
  type: z.ZodOptional<z.ZodEnum<{
1313
- native: "native";
1314
- erc20: "erc20";
1315
1313
  any: "any";
1314
+ erc20: "erc20";
1315
+ native: "native";
1316
1316
  }>>;
1317
1317
  }, z.core.$strip>;
1318
1318
  selection: z.ZodDiscriminatedUnion<[z.ZodObject<{
1319
1319
  kind: z.ZodLiteral<"config">;
1320
1320
  configKey: z.ZodString;
1321
1321
  cardinality: z.ZodEnum<{
1322
- one: "one";
1323
1322
  many: "many";
1323
+ one: "one";
1324
1324
  }>;
1325
1325
  }, z.core.$strip>, z.ZodObject<{
1326
1326
  kind: z.ZodLiteral<"all_matching">;
@@ -1332,9 +1332,9 @@ export declare const ComposeManifestZod: z.ZodObject<{
1332
1332
  kind: z.ZodString;
1333
1333
  description: z.ZodOptional<z.ZodString>;
1334
1334
  accepts: z.ZodEnum<{
1335
- resource: "resource";
1336
1335
  any: "any";
1337
1336
  handle: "handle";
1337
+ resource: "resource";
1338
1338
  }>;
1339
1339
  configSchema: z.ZodOptional<z.ZodUnknown>;
1340
1340
  }, z.core.$strip>>;
@@ -1346,8 +1346,8 @@ export declare const ComposeManifestZod: z.ZodObject<{
1346
1346
  routing: z.ZodOptional<z.ZodObject<{
1347
1347
  maxRouteHops: z.ZodNumber;
1348
1348
  swapHops: z.ZodEnum<{
1349
- none: "none";
1350
1349
  head: "head";
1350
+ none: "none";
1351
1351
  }>;
1352
1352
  }, z.core.$strip>>;
1353
1353
  }, z.core.$strip>;
@@ -1377,16 +1377,16 @@ export declare const AssertionSpecZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
1377
1377
  chainId: z.ZodNumber;
1378
1378
  token: z.ZodString;
1379
1379
  owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
1380
- escrow: "escrow";
1381
1380
  delivery: "delivery";
1381
+ escrow: "escrow";
1382
1382
  }>]>;
1383
1383
  minAmount: z.ZodString;
1384
1384
  }, z.core.$strip>, z.ZodObject<{
1385
1385
  kind: z.ZodLiteral<"nativeBalanceGte">;
1386
1386
  chainId: z.ZodNumber;
1387
1387
  owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
1388
- escrow: "escrow";
1389
1388
  delivery: "delivery";
1389
+ escrow: "escrow";
1390
1390
  }>]>;
1391
1391
  minAmount: z.ZodString;
1392
1392
  }, z.core.$strip>, z.ZodObject<{
@@ -1396,8 +1396,8 @@ export declare const AssertionSpecZod: z.ZodDiscriminatedUnion<[z.ZodObject<{
1396
1396
  signature: z.ZodString;
1397
1397
  args: z.ZodReadonly<z.ZodArray<z.ZodString>>;
1398
1398
  comparator: z.ZodEnum<{
1399
- gte: "gte";
1400
1399
  eq: "eq";
1400
+ gte: "gte";
1401
1401
  lte: "lte";
1402
1402
  }>;
1403
1403
  threshold: z.ZodString;
@@ -1411,16 +1411,16 @@ export declare const VerificationDescriptorZod: z.ZodObject<{
1411
1411
  chainId: z.ZodNumber;
1412
1412
  token: z.ZodString;
1413
1413
  owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
1414
- escrow: "escrow";
1415
1414
  delivery: "delivery";
1415
+ escrow: "escrow";
1416
1416
  }>]>;
1417
1417
  minAmount: z.ZodString;
1418
1418
  }, z.core.$strip>, z.ZodObject<{
1419
1419
  kind: z.ZodLiteral<"nativeBalanceGte">;
1420
1420
  chainId: z.ZodNumber;
1421
1421
  owner: z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
1422
- escrow: "escrow";
1423
1422
  delivery: "delivery";
1423
+ escrow: "escrow";
1424
1424
  }>]>;
1425
1425
  minAmount: z.ZodString;
1426
1426
  }, z.core.$strip>, z.ZodObject<{
@@ -1430,8 +1430,8 @@ export declare const VerificationDescriptorZod: z.ZodObject<{
1430
1430
  signature: z.ZodString;
1431
1431
  args: z.ZodReadonly<z.ZodArray<z.ZodString>>;
1432
1432
  comparator: z.ZodEnum<{
1433
- gte: "gte";
1434
1433
  eq: "eq";
1434
+ gte: "gte";
1435
1435
  lte: "lte";
1436
1436
  }>;
1437
1437
  threshold: z.ZodString;
@@ -1638,7 +1638,7 @@ interface Port {
1638
1638
  }
1639
1639
  export declare const isResourceInput: (input: FlowInput) => input is ResourceInput;
1640
1640
  export declare const flowInputType: (input: FlowInput) => SolType;
1641
- export declare const flowInputMode: (input: FlowInput) => "linear" | "copy";
1641
+ export declare const flowInputMode: (input: FlowInput) => 'linear' | 'copy';
1642
1642
  export declare const flowInputResource: (input: FlowInput) => Resource | undefined;
1643
1643
  export declare const isResourcePort: (port: OpInputPort) => port is ResourcePort;
1644
1644
  export declare const isHandlePort: (port: OpInputPort | OpOutputPort) => port is HandlePort;
@@ -1723,7 +1723,7 @@ export declare const PROVIDER_KIND: {
1723
1723
  readonly BALANCER_V2: 2;
1724
1724
  readonly MORPHO_BLUE: 3;
1725
1725
  };
1726
- export declare const providerKindNames: readonly ["aave-v3", "erc3156", "balancer-v2", "morpho-blue"];
1726
+ export declare const providerKindNames: readonly ['aave-v3', 'erc3156', 'balancer-v2', 'morpho-blue'];
1727
1727
  type ProviderKindName = (typeof providerKindNames)[number];
1728
1728
  export declare const providerKindByName: Record<ProviderKindName, number>;
1729
1729
  interface FlashloanMaterialiserInput {
@@ -1741,12 +1741,12 @@ interface OpHandleOptions<Opt extends boolean = boolean> {
1741
1741
  export declare const linear: <N extends string, T extends SolType>(name: N, type: T) => Port & {
1742
1742
  readonly name: N;
1743
1743
  readonly type: T;
1744
- readonly mode: "linear";
1744
+ readonly mode: 'linear';
1745
1745
  };
1746
1746
  export declare const copy: <N extends string, T extends SolType>(name: N, type: T) => Port & {
1747
1747
  readonly name: N;
1748
1748
  readonly type: T;
1749
- readonly mode: "copy";
1749
+ readonly mode: 'copy';
1750
1750
  };
1751
1751
  export declare const handle: <N extends string, T extends SolType>(name: N, type: T) => HandleInput & {
1752
1752
  readonly name: N;
@@ -1758,15 +1758,15 @@ export declare const native: <N extends string>(name: N, chainId: number) => Res
1758
1758
  export declare const erc20: <N extends string>(name: N, token: string, chainId: number) => ResourceInput & {
1759
1759
  readonly name: N;
1760
1760
  };
1761
- export declare const resource: <N extends string, Opt extends boolean = false>(name: N, accepts: "erc20" | "native" | "any", options?: {
1761
+ export declare const resource: <N extends string, Opt extends boolean = false>(name: N, accepts: 'erc20' | 'native' | 'any', options?: {
1762
1762
  readonly optional?: Opt;
1763
1763
  }) => ResourcePort & {
1764
1764
  readonly name: N;
1765
1765
  readonly optional: NoInfer<Opt>;
1766
1766
  };
1767
- export declare const readResource: <N extends string>(name: N, accepts: "erc20" | "native" | "any") => ResourcePort & {
1767
+ export declare const readResource: <N extends string>(name: N, accepts: 'erc20' | 'native' | 'any') => ResourcePort & {
1768
1768
  readonly name: N;
1769
- readonly mode: "copy";
1769
+ readonly mode: 'copy';
1770
1770
  };
1771
1771
  export declare const opHandle: <N extends string, T extends SolType, Opt extends boolean = false>(name: N, type: T, options?: OpHandleOptions<Opt>) => HandlePort & {
1772
1772
  readonly name: N;
@@ -1788,7 +1788,7 @@ type OutputCountFrom<O> = O extends {
1788
1788
  type OutputAvailability<O> = [O] extends ['future'] ? 'future' : [O] extends ['now'] ? 'now' : [O] extends [string] ? Availability : O extends {
1789
1789
  readonly availability: infer A;
1790
1790
  } ? [A] extends ['future'] ? 'future' : [A] extends ['now'] ? 'now' : Availability : 'now';
1791
- export declare const resourceOutput: <N extends string, const O extends ResourceOutputOptions = "now">(name: N, options?: O) => ResourceOutputPort & {
1791
+ export declare const resourceOutput: <N extends string, const O extends ResourceOutputOptions = 'now'>(name: N, options?: O) => ResourceOutputPort & {
1792
1792
  readonly name: N;
1793
1793
  readonly availability: OutputAvailability<O>;
1794
1794
  } & OutputCountFrom<O>;
@@ -1799,8 +1799,8 @@ type OutputFamilyPort = ResourceOutputPort & {
1799
1799
  };
1800
1800
  export declare const isOutputFamily: (port: OpOutputPort) => port is OutputFamilyPort;
1801
1801
  export declare const instancePortName: (family: string, index: number) => string;
1802
- export declare const familySize: (family: Pick<OutputFamilyPort, "name" | "countFrom">, config: Call["config"]) => number;
1803
- export declare const expandOutputPorts: (declared: readonly OpOutputPort[], config: Call["config"]) => readonly OpOutputPort[];
1802
+ export declare const familySize: (family: Pick<OutputFamilyPort, 'name' | 'countFrom'>, config: Call['config']) => number;
1803
+ export declare const expandOutputPorts: (declared: readonly OpOutputPort[], config: Call['config']) => readonly OpOutputPort[];
1804
1804
  //#endregion
1805
1805
  //#region src/ref.d.ts
1806
1806
  type ParsedRef = {
@@ -2198,9 +2198,9 @@ type Erc20AllowancePrecondition = {
2198
2198
  readonly token: string;
2199
2199
  readonly allowance: bigint | string;
2200
2200
  };
2201
- export declare const erc20Balance: (config: Omit<Erc20BalancePrecondition, "type">) => Erc20BalancePrecondition;
2202
- export declare const nativeBalance: (config: Omit<NativeBalancePrecondition, "type">) => NativeBalancePrecondition;
2203
- export declare const erc20Allowance: (config: Omit<Erc20AllowancePrecondition, "type">) => Erc20AllowancePrecondition;
2201
+ export declare const erc20Balance: (config: Omit<Erc20BalancePrecondition, 'type'>) => Erc20BalancePrecondition;
2202
+ export declare const nativeBalance: (config: Omit<NativeBalancePrecondition, 'type'>) => NativeBalancePrecondition;
2203
+ export declare const erc20Allowance: (config: Omit<Erc20AllowancePrecondition, 'type'>) => Erc20AllowancePrecondition;
2204
2204
  export declare const isErc20BalancePrecondition: (p: Precondition) => p is Erc20BalancePrecondition;
2205
2205
  export declare const isErc20AllowancePrecondition: (p: Precondition) => p is Erc20AllowancePrecondition;
2206
2206
  export declare const isNativeBalancePrecondition: (p: Precondition) => p is NativeBalancePrecondition;