@helios-lang/effect 0.1.14 → 0.2.0

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

@@ -0,0 +1,438 @@
+import { Effect, Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import * as Cbor from "../../Codecs/Cbor.js";
+import { Params } from "../Network";
+import * as Uplc from "../Uplc";
+import * as Address from "./Address.js";
+import * as Assets from "./Assets.js";
+import * as TxOutputDatum from "./TxOutputDatum.js";
+export declare const TxOutputEncodingConfig: Schema.Struct<{
+    strictBabbage: Schema.optional<typeof Schema.Boolean>;
+}>;
+export type TxOutputEncodingConfig = Schema.Schema.Type<typeof TxOutputEncodingConfig>;
+export declare const DEFAULT_TX_OUTPUT_ENCODING_CONFIG: TxOutputEncodingConfig;
+export declare const TxOutput: 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 Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.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 TxOutput = Schema.Schema.Type<typeof TxOutput>;
+export declare const FromUplcData: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+    readonly bytes: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly int: bigint;
+} | {
+    readonly list: readonly Uplc.Data.Data[];
+} | {
+    readonly map: readonly {
+        readonly k: Uplc.Data.Data;
+        readonly v: Uplc.Data.Data;
+    }[];
+} | {
+    readonly fields: readonly Uplc.Data.Data[];
+    readonly constructor: number;
+}, {
+    readonly bytes: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly int: bigint;
+} | {
+    readonly list: readonly Uplc.Data.Data[];
+} | {
+    readonly map: readonly {
+        readonly k: Uplc.Data.Data;
+        readonly v: Uplc.Data.Data;
+    }[];
+} | {
+    readonly fields: readonly Uplc.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 Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.Data.Data[];
+        readonly constructor: number;
+    }, {
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.Data.Data[];
+        readonly constructor: number;
+    }, never>, Schema.Struct<{
+        spendingCredential: Schema.transform<Schema.Schema<({
+            _tag: "PubKey";
+        } & {
+            hash: string;
+        }) | ({
+            _tag: "Validator";
+        } & {
+            hash: string;
+        }), Uplc.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 Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.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 Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.Data.Data[];
+            readonly constructor: number;
+        }, never>>, never>;
+    }>, never>, Schema.SchemaClass<string & import("effect/Brand").Brand<"Address">, string & import("effect/Brand").Brand<"Address">, never>, import("../Network").IsMainnet>;
+    assets: Schema.transform<Schema.transformOrFail<Schema.SchemaClass<{
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.Data.Data[];
+        readonly constructor: number;
+    }, {
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.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 Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.Data.Data[];
+        readonly constructor: number;
+    }, never>, Schema.Schema<readonly (readonly [string, bigint])[], {
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.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 Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.Data.Data[];
+            readonly constructor: number;
+        };
+    }) | ({
+        _tag: "Hash";
+    } & {
+        hash: string & import("effect/Brand").Brand<"DatumHash">;
+    }), Uplc.Data.Data, never>, Schema.Union<[Schema.Union<[Schema.TaggedStruct<"Inline", {
+        data: Schema.SchemaClass<{
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.Data.Data[];
+            readonly constructor: number;
+        }, {
+            readonly bytes: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly int: bigint;
+        } | {
+            readonly list: readonly Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.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 Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.Data.Data[];
+        readonly constructor: number;
+    }, {
+        readonly bytes: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly int: bigint;
+    } | {
+        readonly list: readonly Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.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 Uplc.Data.Data[];
+    } | {
+        readonly map: readonly {
+            readonly k: Uplc.Data.Data;
+            readonly v: Uplc.Data.Data;
+        }[];
+    } | {
+        readonly fields: readonly Uplc.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 Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.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 Uplc.Data.Data[];
+        } | {
+            readonly map: readonly {
+                readonly k: Uplc.Data.Data;
+                readonly v: Uplc.Data.Data;
+            }[];
+        } | {
+            readonly fields: readonly Uplc.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({ address, assets, datum, refScript, encodingConfig }: {
+    address: Address.Address;
+    assets: Assets.Assets;
+    datum?: TxOutputDatum.TxOutputDatum;
+    refScript?: Uplc.Script.Script<2> | Uplc.Script.Script<3>;
+    encodingConfig?: TxOutputEncodingConfig;
+}): TxOutput;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<TxOutput>;
+export declare function encode(output: TxOutput): number[];
+export declare const minLovelace: (output: TxOutput) => Effect.Effect<bigint, never, Params.params>;
+export declare const sumAssets: (...outputs: TxOutput[]) => {
+    readonly [x: string]: bigint;
+};
+//# sourceMappingURL=TxOutput.d.ts.map

package/types/Cardano/Ledger/TxOutput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TxOutput.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/TxOutput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAkB,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvD,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAA;AAC9C,OAAO,KAAK,IAAI,MAAM,sBAAsB,CAAA;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,IAAI,MAAM,SAAS,CAAA;AAC/B,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAErC,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAGnD,eAAO,MAAM,sBAAsB;;EAEjC,CAAA;AAEF,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CACrD,OAAO,sBAAsB,CAC9B,CAAA;AAED,eAAO,MAAM,iCAAiC,EAAE,sBAE/C,CAAA;AAED,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE1D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAyBxB,CAAA;AAED,wBAAgB,IAAI,CAAC,EACnB,OAAO,EACP,MAAM,EACN,KAAiB,EACjB,SAAqB,EACrB,cAAkD,EACnD,EAAE;IACD,OAAO,EAAE,OAAO,CAAC,OAAO,CAAA;IACxB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAA;IACrB,KAAK,CAAC,EAAE,aAAa,CAAC,aAAa,CAAA;IACnC,SAAS,CAAC,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACzD,cAAc,CAAC,EAAE,sBAAsB,CAAA;CACxC,GAAG,QAAQ,CAQX;AAED,eAAO,MAAM,MAAM,GAAI,OAAO,KAAK,CAAC,SAAS,KAAG,IAAI,CAAC,YAAY,CAAC,QAAQ,CA8GtE,CAAA;AAEJ,wBAAgB,MAAM,CAAC,MAAM,EAAE,QAAQ,GAAG,MAAM,EAAE,CA+CjD;AAED,eAAO,MAAM,WAAW,GAAI,QAAQ,QAAQ,gDAUzC,CAAA;AAEH,eAAO,MAAM,SAAS,GAAI,GAAG,SAAS,QAAQ,EAAE;;CACO,CAAA"}

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

@@ -0,0 +1,98 @@
+import { Schema } from "effect";
+import * as Bytes from "../../Codecs/Bytes.js";
+import * as Cbor from "../../Codecs/Cbor.js";
+import * as Data from "../Uplc/Data.js";
+export declare const TxOutputDatum: 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">;
+}>]>;
+export type TxOutputDatum = Schema.Schema.Type<typeof TxOutputDatum>;
+export declare const FromUplcData: 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]>>;
+export declare const decode: (bytes: Bytes.BytesLike) => Cbor.DecodeResult<TxOutputDatum>;
+export declare function encode(txOutputDatum: TxOutputDatum): number[];
+//# sourceMappingURL=TxOutputDatum.d.ts.map

package/types/Cardano/Ledger/TxOutputDatum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TxOutputDatum.d.ts","sourceRoot":"","sources":["../../../src/Cardano/Ledger/TxOutputDatum.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,MAAM,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAA;AAC9C,OAAO,KAAK,IAAI,MAAM,sBAAsB,CAAA;AAC5C,OAAO,KAAK,IAAI,MAAM,iBAAiB,CAAA;AAGvC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGzB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,aAAa,CAAC,CAAA;AAEpE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAoCxB,CAAA;AAED,eAAO,MAAM,MAAM,GACjB,OAAO,KAAK,CAAC,SAAS,KACrB,IAAI,CAAC,YAAY,CAAC,aAAa,CA+B9B,CAAA;AAEJ,wBAAgB,MAAM,CAAC,aAAa,EAAE,aAAa,GAAG,MAAM,EAAE,CAe7D"}