@helios-lang/effect 0.1.14 → 0.2.0

package/types/Cardano/Ledger/UTxO.d.ts

@@ -0,0 +1,1420 @@
+import { Effect, Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import * as Cbor from "../../Codecs/Cbor.js";
+import * as Network from "../Network";
+import * as Data from "../Uplc/Data.js";
+import * as Assets from "./Assets.js";
+import * as TxOutput from "./TxOutput.js";
+import * as UTxORef from "./UTxORef.js";
+export declare const UTxO: Schema.Struct<{
+    ref: Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "UTxORef">>;
+    output: Schema.Struct<{
+        address: Schema.brand<Schema.filter<typeof Schema.String>, "Address">;
+        assets: Schema.filter<Schema.Record$<typeof Schema.String, typeof Schema.BigIntFromSelf>>;
+        datum: Schema.optional<Schema.Union<[Schema.TaggedStruct<"Inline", {
+            data: Schema.SchemaClass<{
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, never>;
+        }>, Schema.TaggedStruct<"Hash", {
+            hash: Schema.brand<Schema.filter<typeof Schema.String>, "DatumHash">;
+        }>]>>;
+        refScript: Schema.optional<Schema.Union<[Schema.extend<Schema.Struct<{
+            root: Schema.Schema<Uint8Array<ArrayBufferLike>, string, never>;
+            verbose: Schema.optional<Schema.Schema<Uint8Array<ArrayBufferLike>, string, never>>;
+        }>, Schema.Struct<{
+            version: Schema.Literal<[2]>;
+        }>>, Schema.extend<Schema.Struct<{
+            root: Schema.Schema<Uint8Array<ArrayBufferLike>, string, never>;
+            verbose: Schema.optional<Schema.Schema<Uint8Array<ArrayBufferLike>, string, never>>;
+        }>, Schema.Struct<{
+            version: Schema.Literal<[3]>;
+        }>>]>>;
+        encodingConfig: Schema.optional<Schema.Struct<{
+            strictBabbage: Schema.optional<typeof Schema.Boolean>;
+        }>>;
+    }>;
+}>;
+export type UTxO = Schema.Schema.Type<typeof UTxO>;
+export declare const FromUplcData: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+    readonly bytes: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly int: bigint;
+} | {
+    readonly list: readonly Data.Data[];
+} | {
+    readonly map: readonly {
+        readonly k: Data.Data;
+        readonly v: Data.Data;
+    }[];
+} | {
+    readonly fields: readonly Data.Data[];
+    readonly constructor: number;
+}, {
+    readonly bytes: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly int: bigint;
+} | {
+    readonly list: readonly Data.Data[];
+} | {
+    readonly map: readonly {
+        readonly k: Data.Data;
+        readonly v: Data.Data;
+    }[];
+} | {
+    readonly fields: readonly Data.Data[];
+    readonly constructor: number;
+}, never>, Schema.Struct<{
+    ref: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Data.Data;
+            readonly v: Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Data.Data[];
+        readonly constructor: number;
+    }, {
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Data.Data;
+            readonly v: Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Data.Data[];
+        readonly constructor: number;
+    }, never>, Schema.Struct<{
+        txHash: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, Schema.Struct<{
+            bytes: Schema.transformOrFail<Schema.SchemaClass<{
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, never>, typeof Schema.Uint8ArrayFromSelf, never>;
+        }>, never>, Schema.brand<Schema.filter<typeof Schema.String>, "TxHash">>;
+        index: Schema.transformOrFail<Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, typeof Schema.Int, never>;
+    }>, never>, Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "UTxORef">>>;
+    output: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Data.Data;
+            readonly v: Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Data.Data[];
+        readonly constructor: number;
+    }, {
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Data.Data;
+            readonly v: Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Data.Data[];
+        readonly constructor: number;
+    }, never>, Schema.Struct<{
+        address: Schema.transformOrFail<Schema.transformOrFail<Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, Schema.Struct<{
+            spendingCredential: Schema.transform<Schema.Schema<({
+                _tag: "PubKey";
+            } & {
+                hash: string;
+            }) | ({
+                _tag: "Validator";
+            } & {
+                hash: string;
+            }), Data.Data, never>, Schema.Union<[Schema.TaggedStruct<"PubKey", {
+                hash: Schema.brand<Schema.filter<typeof Schema.String>, "PubKeyHash">;
+            }>, Schema.TaggedStruct<"Validator", {
+                hash: Schema.brand<Schema.filter<typeof Schema.String>, "ValidatorHash">;
+            }>]>>;
+            stakingCredential: Schema.transformOrFail<Schema.SchemaClass<{
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, never>, Schema.Option<Schema.Schema<{
+                readonly _tag: "PubKey";
+                readonly hash: string & import("effect/Brand").Brand<"PubKeyHash">;
+            } | {
+                readonly _tag: "Validator";
+                readonly hash: string & import("effect/Brand").Brand<"ValidatorHash">;
+            }, {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, never>>, never>;
+        }>, never>, Schema.SchemaClass<string & import("effect/Brand").Brand<"Address">, string & import("effect/Brand").Brand<"Address">, never>, Network.IsMainnet>;
+        assets: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, Schema.Array$<Schema.Tuple2<Schema.Schema<string & import("effect/Brand").Brand<"MintingPolicy">, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, Schema.Schema<readonly (readonly [string, bigint])[], {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>>>, never>, Schema.filter<Schema.Record$<typeof Schema.String, typeof Schema.BigIntFromSelf>>>;
+        datum: Schema.transform<Schema.Schema<({
+            _tag: "None";
+        } & {}) | ({
+            _tag: "Inline";
+        } & {
+            data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        }) | ({
+            _tag: "Hash";
+        } & {
+            hash: string & import("effect/Brand").Brand<"DatumHash">;
+        }), Data.Data, never>, Schema.Union<[Schema.Union<[Schema.TaggedStruct<"Inline", {
+            data: Schema.SchemaClass<{
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, never>;
+        }>, Schema.TaggedStruct<"Hash", {
+            hash: Schema.brand<Schema.filter<typeof Schema.String>, "DatumHash">;
+        }>]>, typeof Schema.Undefined]>>;
+        refScript: Schema.transformOrFail<Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, Schema.Option<Schema.Schema<string & import("effect/Brand").Brand<"ValidatorHash">, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>>, never>;
+    }>, never>, Schema.SchemaClass<{
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    }, {
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    }, never>>;
+}>, never>, Schema.SchemaClass<{
+    readonly ref: string & import("effect/Brand").Brand<"UTxORef">;
+    readonly output: {
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    };
+}, {
+    readonly ref: string & import("effect/Brand").Brand<"UTxORef">;
+    readonly output: {
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    };
+}, never>>;
+export declare const FromUplcDataV3: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+    readonly bytes: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly int: bigint;
+} | {
+    readonly list: readonly Data.Data[];
+} | {
+    readonly map: readonly {
+        readonly k: Data.Data;
+        readonly v: Data.Data;
+    }[];
+} | {
+    readonly fields: readonly Data.Data[];
+    readonly constructor: number;
+}, {
+    readonly bytes: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly int: bigint;
+} | {
+    readonly list: readonly Data.Data[];
+} | {
+    readonly map: readonly {
+        readonly k: Data.Data;
+        readonly v: Data.Data;
+    }[];
+} | {
+    readonly fields: readonly Data.Data[];
+    readonly constructor: number;
+}, never>, Schema.Struct<{
+    ref: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Data.Data;
+            readonly v: Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Data.Data[];
+        readonly constructor: number;
+    }, {
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Data.Data;
+            readonly v: Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Data.Data[];
+        readonly constructor: number;
+    }, never>, Schema.Struct<{
+        txHash: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, typeof Schema.String, never>, Schema.brand<Schema.filter<typeof Schema.String>, "TxHash">>;
+        index: Schema.transformOrFail<Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, typeof Schema.Int, never>;
+    }>, never>, Schema.transform<typeof Schema.String, Schema.brand<Schema.filter<typeof Schema.String>, "UTxORef">>>;
+    output: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Data.Data;
+            readonly v: Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Data.Data[];
+        readonly constructor: number;
+    }, {
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Data.Data;
+            readonly v: Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Data.Data[];
+        readonly constructor: number;
+    }, never>, Schema.Struct<{
+        address: Schema.transformOrFail<Schema.transformOrFail<Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, Schema.Struct<{
+            spendingCredential: Schema.transform<Schema.Schema<({
+                _tag: "PubKey";
+            } & {
+                hash: string;
+            }) | ({
+                _tag: "Validator";
+            } & {
+                hash: string;
+            }), Data.Data, never>, Schema.Union<[Schema.TaggedStruct<"PubKey", {
+                hash: Schema.brand<Schema.filter<typeof Schema.String>, "PubKeyHash">;
+            }>, Schema.TaggedStruct<"Validator", {
+                hash: Schema.brand<Schema.filter<typeof Schema.String>, "ValidatorHash">;
+            }>]>>;
+            stakingCredential: Schema.transformOrFail<Schema.SchemaClass<{
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, never>, Schema.Option<Schema.Schema<{
+                readonly _tag: "PubKey";
+                readonly hash: string & import("effect/Brand").Brand<"PubKeyHash">;
+            } | {
+                readonly _tag: "Validator";
+                readonly hash: string & import("effect/Brand").Brand<"ValidatorHash">;
+            }, {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, never>>, never>;
+        }>, never>, Schema.SchemaClass<string & import("effect/Brand").Brand<"Address">, string & import("effect/Brand").Brand<"Address">, never>, Network.IsMainnet>;
+        assets: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, Schema.Array$<Schema.Tuple2<Schema.Schema<string & import("effect/Brand").Brand<"MintingPolicy">, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, Schema.Schema<readonly (readonly [string, bigint])[], {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>>>, never>, Schema.filter<Schema.Record$<typeof Schema.String, typeof Schema.BigIntFromSelf>>>;
+        datum: Schema.transform<Schema.Schema<({
+            _tag: "None";
+        } & {}) | ({
+            _tag: "Inline";
+        } & {
+            data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        }) | ({
+            _tag: "Hash";
+        } & {
+            hash: string & import("effect/Brand").Brand<"DatumHash">;
+        }), Data.Data, never>, Schema.Union<[Schema.Union<[Schema.TaggedStruct<"Inline", {
+            data: Schema.SchemaClass<{
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            }, never>;
+        }>, Schema.TaggedStruct<"Hash", {
+            hash: Schema.brand<Schema.filter<typeof Schema.String>, "DatumHash">;
+        }>]>, typeof Schema.Undefined]>>;
+        refScript: Schema.transformOrFail<Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>, Schema.Option<Schema.Schema<string & import("effect/Brand").Brand<"ValidatorHash">, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Data.Data;
+                readonly v: Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Data.Data[];
+            readonly constructor: number;
+        }, never>>, never>;
+    }>, never>, Schema.SchemaClass<{
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    }, {
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    }, never>>;
+}>, never>, Schema.SchemaClass<{
+    readonly ref: string & import("effect/Brand").Brand<"UTxORef">;
+    readonly output: {
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    };
+}, {
+    readonly ref: string & import("effect/Brand").Brand<"UTxORef">;
+    readonly output: {
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    };
+}, never>>;
+export declare function make(ref: UTxORef.UTxORef, output: TxOutput.TxOutput): UTxO;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<UTxO | UTxORef.UTxORef>;
+export declare const decodeFull: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<UTxO>;
+export declare const encode: (options: {
+    full?: boolean;
+}) => (utxo: UTxO) => number[];
+export declare const resolve: (options: {
+    trusted?: boolean;
+}) => (utxo: UTxO | UTxORef.UTxORef) => Effect.Effect<{
+    readonly ref: string & import("effect/Brand").Brand<"UTxORef">;
+    readonly output: {
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    };
+}, Network.ConnectionError | Network.UnexpectedFormat | Network.UTxONotFound | Network.UTxOAlreadySpent, Network.UTxO>;
+export declare const resolveAll: (options: {
+    trusted?: boolean;
+}) => (utxos: (UTxO | UTxORef.UTxORef)[]) => Effect.Effect<{
+    readonly ref: string & import("effect/Brand").Brand<"UTxORef">;
+    readonly output: {
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    };
+}[], Network.ConnectionError | Network.UnexpectedFormat | Network.UTxONotFound | Network.UTxOAlreadySpent, Network.UTxO>;
+/**
+ * For sorting lists of UTxOs
+ * @param a
+ * @param b
+ */
+export declare function compare(a: UTxO, b: UTxO): number;
+export declare const sumAssets: (...utxos: readonly UTxO[]) => Assets.Assets;
+export declare const difference: (set: readonly UTxO[], exclude: readonly UTxO[]) => {
+    readonly ref: string & import("effect/Brand").Brand<"UTxORef">;
+    readonly output: {
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    };
+}[];
+/**
+ * Resorts the list after appending
+ * @param list
+ * Not mutated
+ * @param utxo
+ * @returns
+ */
+export declare const append: (list: readonly UTxO[], ...utxos: UTxO[]) => {
+    readonly ref: string & import("effect/Brand").Brand<"UTxORef">;
+    readonly output: {
+        readonly address: string & import("effect/Brand").Brand<"Address">;
+        readonly assets: {
+            readonly [x: string]: bigint;
+        };
+        readonly datum?: {
+            readonly _tag: "Inline";
+            readonly data: {
+                readonly bytes: Uint8Array<ArrayBufferLike>;
+            } | {
+                readonly int: bigint;
+            } | {
+                readonly list: readonly Data.Data[];
+            } | {
+                readonly map: readonly {
+                    readonly k: Data.Data;
+                    readonly v: Data.Data;
+                }[];
+            } | {
+                readonly fields: readonly Data.Data[];
+                readonly constructor: number;
+            };
+        } | {
+            readonly _tag: "Hash";
+            readonly hash: string & import("effect/Brand").Brand<"DatumHash">;
+        } | undefined;
+        readonly refScript?: ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 2;
+        }) | ({
+            readonly root: Uint8Array<ArrayBufferLike>;
+            readonly verbose?: Uint8Array<ArrayBufferLike> | undefined;
+        } & {
+            readonly version: 3;
+        }) | undefined;
+        readonly encodingConfig?: {
+            readonly strictBabbage?: boolean | undefined;
+        } | undefined;
+    };
+}[];
+//# sourceMappingURL=UTxO.d.ts.map