@bubolabs/wallet-wasm 0.1.0

package/pkg-cardano/bubo_wallet_wasm.d.ts

@@ -0,0 +1,4367 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export class Address {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): Address;
+    static from_bytes(data: Uint8Array): Address;
+    static from_hex(hex_str: string): Address;
+    static from_json(json: string): Address;
+    is_malformed(): boolean;
+    kind(): AddressKind;
+    network_id(): number;
+    payment_cred(): Credential | undefined;
+    to_bech32(prefix?: string | null): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export enum AddressKind {
+    Base = 0,
+    Pointer = 1,
+    Enterprise = 2,
+    Reward = 3,
+    Byron = 4,
+    Malformed = 5,
+}
+
+export class Anchor {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    anchor_data_hash(): AnchorDataHash;
+    static from_bytes(bytes: Uint8Array): Anchor;
+    static from_hex(hex_str: string): Anchor;
+    static from_json(json: string): Anchor;
+    static new(anchor_url: URL, anchor_data_hash: AnchorDataHash): Anchor;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    url(): URL;
+}
+
+export class AnchorDataHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): AnchorDataHash;
+    static from_bytes(bytes: Uint8Array): AnchorDataHash;
+    static from_hex(hex: string): AnchorDataHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class AssetName {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): AssetName;
+    static from_hex(hex_str: string): AssetName;
+    static from_json(json: string): AssetName;
+    name(): Uint8Array;
+    static new(name: Uint8Array): AssetName;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class AssetNames {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: AssetName): void;
+    static from_bytes(bytes: Uint8Array): AssetNames;
+    static from_hex(hex_str: string): AssetNames;
+    static from_json(json: string): AssetNames;
+    get(index: number): AssetName;
+    len(): number;
+    static new(): AssetNames;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Assets {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): Assets;
+    static from_hex(hex_str: string): Assets;
+    static from_json(json: string): Assets;
+    get(key: AssetName): BigNum | undefined;
+    insert(key: AssetName, value: BigNum): BigNum | undefined;
+    keys(): AssetNames;
+    len(): number;
+    static new(): Assets;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class AuxiliaryData {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): AuxiliaryData;
+    static from_hex(hex_str: string): AuxiliaryData;
+    static from_json(json: string): AuxiliaryData;
+    metadata(): GeneralTransactionMetadata | undefined;
+    native_scripts(): NativeScripts | undefined;
+    static new(): AuxiliaryData;
+    plutus_scripts(): PlutusScripts | undefined;
+    prefer_alonzo_format(): boolean;
+    set_metadata(metadata: GeneralTransactionMetadata): void;
+    set_native_scripts(native_scripts: NativeScripts): void;
+    set_plutus_scripts(plutus_scripts: PlutusScripts): void;
+    set_prefer_alonzo_format(prefer: boolean): void;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class AuxiliaryDataHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): AuxiliaryDataHash;
+    static from_bytes(bytes: Uint8Array): AuxiliaryDataHash;
+    static from_hex(hex: string): AuxiliaryDataHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class AuxiliaryDataSet {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    get(tx_index: number): AuxiliaryData | undefined;
+    indices(): Uint32Array;
+    insert(tx_index: number, data: AuxiliaryData): AuxiliaryData | undefined;
+    len(): number;
+    static new(): AuxiliaryDataSet;
+}
+
+export class BaseAddress {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_address(addr: Address): BaseAddress | undefined;
+    network_id(): number;
+    static new(network: number, payment: Credential, stake: Credential): BaseAddress;
+    payment_cred(): Credential;
+    stake_cred(): Credential;
+    to_address(): Address;
+}
+
+export class BigInt {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    abs(): BigInt;
+    add(other: BigInt): BigInt;
+    as_int(): Int | undefined;
+    as_u64(): BigNum | undefined;
+    div_ceil(other: BigInt): BigInt;
+    div_floor(other: BigInt): BigInt;
+    static from_bytes(bytes: Uint8Array): BigInt;
+    static from_hex(hex_str: string): BigInt;
+    static from_json(json: string): BigInt;
+    static from_str(text: string): BigInt;
+    increment(): BigInt;
+    is_zero(): boolean;
+    mul(other: BigInt): BigInt;
+    static one(): BigInt;
+    pow(exp: number): BigInt;
+    sub(other: BigInt): BigInt;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    to_str(): string;
+    static zero(): BigInt;
+}
+
+export class BigNum {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    checked_add(other: BigNum): BigNum;
+    checked_mul(other: BigNum): BigNum;
+    checked_sub(other: BigNum): BigNum;
+    /**
+     * returns 0 if it would otherwise underflow
+     */
+    clamped_sub(other: BigNum): BigNum;
+    compare(rhs_value: BigNum): number;
+    div_floor(other: BigNum): BigNum;
+    static from_bytes(bytes: Uint8Array): BigNum;
+    static from_hex(hex_str: string): BigNum;
+    static from_json(json: string): BigNum;
+    static from_str(string: string): BigNum;
+    is_zero(): boolean;
+    less_than(rhs_value: BigNum): boolean;
+    static max(a: BigNum, b: BigNum): BigNum;
+    static max_value(): BigNum;
+    static one(): BigNum;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    to_str(): string;
+    static zero(): BigNum;
+}
+
+export class Bip32PrivateKey {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_bytes(): Uint8Array;
+    chaincode(): Uint8Array;
+    /**
+     * derive this private key with the given index.
+     *
+     * # Security considerations
+     *
+     * * hard derivation index cannot be soft derived with the public key
+     *
+     * # Hard derivation vs Soft derivation
+     *
+     * If you pass an index below 0x80000000 then it is a soft derivation.
+     * The advantage of soft derivation is that it is possible to derive the
+     * public key too. I.e. derivation the private key with a soft derivation
+     * index and then retrieving the associated public key is equivalent to
+     * deriving the public key associated to the parent private key.
+     *
+     * Hard derivation index does not allow public key derivation.
+     *
+     * This is why deriving the private key should not fail while deriving
+     * the public key may fail (if the derivation index is invalid).
+     */
+    derive(index: number): Bip32PrivateKey;
+    /**
+     * 128-byte xprv a key format in Cardano that some software still uses or requires
+     * the traditional 96-byte xprv is simply encoded as
+     * prv | chaincode
+     * however, because some software may not know how to compute a public key from a private key,
+     * the 128-byte inlines the public key in the following format
+     * prv | pub | chaincode
+     * so be careful if you see the term "xprv" as it could refer to either one
+     * our library does not require the pub (instead we compute the pub key when needed)
+     */
+    static from_128_xprv(bytes: Uint8Array): Bip32PrivateKey;
+    static from_bech32(bech32_str: string): Bip32PrivateKey;
+    static from_bip39_entropy(entropy: Uint8Array, password: Uint8Array): Bip32PrivateKey;
+    static from_bytes(bytes: Uint8Array): Bip32PrivateKey;
+    static from_hex(hex_str: string): Bip32PrivateKey;
+    static generate_ed25519_bip32(): Bip32PrivateKey;
+    /**
+     * see from_128_xprv
+     */
+    to_128_xprv(): Uint8Array;
+    to_bech32(): string;
+    to_hex(): string;
+    to_public(): Bip32PublicKey;
+    to_raw_key(): PrivateKey;
+}
+
+export class Bip32PublicKey {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_bytes(): Uint8Array;
+    chaincode(): Uint8Array;
+    /**
+     * derive this public key with the given index.
+     *
+     * # Errors
+     *
+     * If the index is not a soft derivation index (< 0x80000000) then
+     * calling this method will fail.
+     *
+     * # Security considerations
+     *
+     * * hard derivation index cannot be soft derived with the public key
+     *
+     * # Hard derivation vs Soft derivation
+     *
+     * If you pass an index below 0x80000000 then it is a soft derivation.
+     * The advantage of soft derivation is that it is possible to derive the
+     * public key too. I.e. derivation the private key with a soft derivation
+     * index and then retrieving the associated public key is equivalent to
+     * deriving the public key associated to the parent private key.
+     *
+     * Hard derivation index does not allow public key derivation.
+     *
+     * This is why deriving the private key should not fail while deriving
+     * the public key may fail (if the derivation index is invalid).
+     */
+    derive(index: number): Bip32PublicKey;
+    static from_bech32(bech32_str: string): Bip32PublicKey;
+    static from_bytes(bytes: Uint8Array): Bip32PublicKey;
+    static from_hex(hex_str: string): Bip32PublicKey;
+    to_bech32(): string;
+    to_hex(): string;
+    to_raw_key(): PublicKey;
+}
+
+export class Block {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    auxiliary_data_set(): AuxiliaryDataSet;
+    static from_bytes(bytes: Uint8Array): Block;
+    static from_hex(hex_str: string): Block;
+    static from_json(json: string): Block;
+    header(): Header;
+    invalid_transactions(): Uint32Array;
+    static new(header: Header, transaction_bodies: TransactionBodies, transaction_witness_sets: TransactionWitnessSets, auxiliary_data_set: AuxiliaryDataSet, invalid_transactions: Uint32Array): Block;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    transaction_bodies(): TransactionBodies;
+    transaction_witness_sets(): TransactionWitnessSets;
+}
+
+export enum BlockEra {
+    Byron = 0,
+    Shelley = 1,
+    Allegra = 2,
+    Mary = 3,
+    Alonzo = 4,
+    Babbage = 5,
+    Conway = 6,
+    Unknown = 7,
+}
+
+export class BlockHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): BlockHash;
+    static from_bytes(bytes: Uint8Array): BlockHash;
+    static from_hex(hex: string): BlockHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class BootstrapWitness {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    attributes(): Uint8Array;
+    chain_code(): Uint8Array;
+    static from_bytes(bytes: Uint8Array): BootstrapWitness;
+    static from_hex(hex_str: string): BootstrapWitness;
+    static from_json(json: string): BootstrapWitness;
+    static new(vkey: Vkey, signature: Ed25519Signature, chain_code: Uint8Array, attributes: Uint8Array): BootstrapWitness;
+    signature(): Ed25519Signature;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    vkey(): Vkey;
+}
+
+export class BootstrapWitnesses {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a new `BootstrapWitness` to the set.
+     * Returns `true` if the element was not already present in the set.
+     */
+    add(witness: BootstrapWitness): boolean;
+    static from_bytes(bytes: Uint8Array): BootstrapWitnesses;
+    static from_hex(hex_str: string): BootstrapWitnesses;
+    static from_json(json: string): BootstrapWitnesses;
+    get(index: number): BootstrapWitness;
+    len(): number;
+    static new(): BootstrapWitnesses;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class ByronAddress {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    attributes(): Uint8Array;
+    byron_address_kind(): ByronAddressType;
+    /**
+     * returns the byron protocol magic embedded in the address, or mainnet id if none is present
+     * note: for bech32 addresses, you need to use network_id instead
+     */
+    byron_protocol_magic(): number;
+    static from_address(addr: Address): ByronAddress | undefined;
+    static from_base58(s: string): ByronAddress;
+    static from_bytes(bytes: Uint8Array): ByronAddress;
+    static icarus_from_key(key: Bip32PublicKey, protocol_magic: number): ByronAddress;
+    static is_valid(s: string): boolean;
+    network_id(): number;
+    to_address(): Address;
+    to_base58(): string;
+    to_bytes(): Uint8Array;
+}
+
+export enum ByronAddressType {
+    ATPubKey = 0,
+    ATScript = 1,
+    ATRedeem = 2,
+}
+
+export enum CborContainerType {
+    Array = 0,
+    Map = 1,
+}
+
+export enum CborSetType {
+    Tagged = 0,
+    Untagged = 1,
+}
+
+export class Certificate {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_committee_cold_resign(): CommitteeColdResign | undefined;
+    as_committee_hot_auth(): CommitteeHotAuth | undefined;
+    as_drep_deregistration(): DRepDeregistration | undefined;
+    as_drep_registration(): DRepRegistration | undefined;
+    as_drep_update(): DRepUpdate | undefined;
+    as_genesis_key_delegation(): GenesisKeyDelegation | undefined;
+    as_move_instantaneous_rewards_cert(): MoveInstantaneousRewardsCert | undefined;
+    as_pool_registration(): PoolRegistration | undefined;
+    as_pool_retirement(): PoolRetirement | undefined;
+    /**
+     * Since StakeRegistration can represent stake_registration certificate or reg_cert certificate, because both certificates have the same semantics.
+     * And in some cases you want to get a reg_cert, this function is used to get a reg_cert.
+     * The function will return None if StakeRegistration represents a stake_registration certificate or Certificate is not a StakeRegistration.
+     */
+    as_reg_cert(): StakeRegistration | undefined;
+    as_stake_and_vote_delegation(): StakeAndVoteDelegation | undefined;
+    as_stake_delegation(): StakeDelegation | undefined;
+    as_stake_deregistration(): StakeDeregistration | undefined;
+    as_stake_registration(): StakeRegistration | undefined;
+    as_stake_registration_and_delegation(): StakeRegistrationAndDelegation | undefined;
+    as_stake_vote_registration_and_delegation(): StakeVoteRegistrationAndDelegation | undefined;
+    /**
+     * Since StakeDeregistration can represent stake_deregistration certificate or unreg_cert certificate, because both certificates have the same semantics.
+     * And in some cases you want to get an unreg_cert, this function is used to get an unreg_cert.
+     * The function will return None if StakeDeregistration represents a stake_deregistration certificate or Certificate is not a StakeDeregistration.
+     */
+    as_unreg_cert(): StakeDeregistration | undefined;
+    as_vote_delegation(): VoteDelegation | undefined;
+    as_vote_registration_and_delegation(): VoteRegistrationAndDelegation | undefined;
+    static from_bytes(bytes: Uint8Array): Certificate;
+    static from_hex(hex_str: string): Certificate;
+    static from_json(json: string): Certificate;
+    has_required_script_witness(): boolean;
+    kind(): CertificateKind;
+    static new_committee_cold_resign(committee_cold_resign: CommitteeColdResign): Certificate;
+    static new_committee_hot_auth(committee_hot_auth: CommitteeHotAuth): Certificate;
+    static new_drep_deregistration(drep_deregistration: DRepDeregistration): Certificate;
+    static new_drep_registration(drep_registration: DRepRegistration): Certificate;
+    static new_drep_update(drep_update: DRepUpdate): Certificate;
+    static new_genesis_key_delegation(genesis_key_delegation: GenesisKeyDelegation): Certificate;
+    static new_move_instantaneous_rewards_cert(move_instantaneous_rewards_cert: MoveInstantaneousRewardsCert): Certificate;
+    static new_pool_registration(pool_registration: PoolRegistration): Certificate;
+    static new_pool_retirement(pool_retirement: PoolRetirement): Certificate;
+    /**
+     * Since StakeRegistration can represent stake_registration certificate or reg_cert certificate, because both certificates have the same semantics.
+     * And in some cases you want to create a reg_cert, this function is used to create a reg_cert.
+     * The function will return an error if StakeRegistration represents a stake_registration certificate.
+     */
+    static new_reg_cert(stake_registration: StakeRegistration): Certificate;
+    static new_stake_and_vote_delegation(stake_and_vote_delegation: StakeAndVoteDelegation): Certificate;
+    static new_stake_delegation(stake_delegation: StakeDelegation): Certificate;
+    static new_stake_deregistration(stake_deregistration: StakeDeregistration): Certificate;
+    static new_stake_registration(stake_registration: StakeRegistration): Certificate;
+    static new_stake_registration_and_delegation(stake_registration_and_delegation: StakeRegistrationAndDelegation): Certificate;
+    static new_stake_vote_registration_and_delegation(stake_vote_registration_and_delegation: StakeVoteRegistrationAndDelegation): Certificate;
+    /**
+     * Since StakeDeregistration can represent stake_deregistration certificate or unreg_cert certificate, because both certificates have the same semantics.
+     * And in some cases you want to create an unreg_cert, this function is used to create an unreg_cert.
+     * The function will return an error if StakeDeregistration represents a stake_deregistration certificate.
+     */
+    static new_unreg_cert(stake_deregistration: StakeDeregistration): Certificate;
+    static new_vote_delegation(vote_delegation: VoteDelegation): Certificate;
+    static new_vote_registration_and_delegation(vote_registration_and_delegation: VoteRegistrationAndDelegation): Certificate;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export enum CertificateKind {
+    StakeRegistration = 0,
+    StakeDeregistration = 1,
+    StakeDelegation = 2,
+    PoolRegistration = 3,
+    PoolRetirement = 4,
+    GenesisKeyDelegation = 5,
+    MoveInstantaneousRewardsCert = 6,
+    CommitteeHotAuth = 7,
+    CommitteeColdResign = 8,
+    DRepDeregistration = 9,
+    DRepRegistration = 10,
+    DRepUpdate = 11,
+    StakeAndVoteDelegation = 12,
+    StakeRegistrationAndDelegation = 13,
+    StakeVoteRegistrationAndDelegation = 14,
+    VoteDelegation = 15,
+    VoteRegistrationAndDelegation = 16,
+}
+
+export class Certificates {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a new `Certificate` to the set.
+     * Returns `true` if the element was not already present in the set.
+     */
+    add(elem: Certificate): boolean;
+    static from_bytes(bytes: Uint8Array): Certificates;
+    static from_hex(hex_str: string): Certificates;
+    static from_json(json: string): Certificates;
+    get(index: number): Certificate;
+    len(): number;
+    static new(): Certificates;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class CertificatesBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(cert: Certificate): void;
+    add_with_native_script(cert: Certificate, native_script_source: NativeScriptSource): void;
+    add_with_plutus_witness(cert: Certificate, witness: PlutusWitness): void;
+    build(): Certificates;
+    get_certificates_deposit(pool_deposit: BigNum, key_deposit: BigNum): BigNum;
+    get_certificates_refund(pool_deposit: BigNum, key_deposit: BigNum): Value;
+    get_native_scripts(): NativeScripts;
+    get_plutus_witnesses(): PlutusWitnesses;
+    get_ref_inputs(): TransactionInputs;
+    has_plutus_scripts(): boolean;
+    static new(): CertificatesBuilder;
+}
+
+export class ChangeConfig {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    change_address(address: Address): ChangeConfig;
+    change_plutus_data(plutus_data: OutputDatum): ChangeConfig;
+    change_script_ref(script_ref: ScriptRef): ChangeConfig;
+    static new(address: Address): ChangeConfig;
+}
+
+export enum CoinSelectionStrategyCIP2 {
+    /**
+     * Performs CIP2's Largest First ada-only selection. Will error if outputs contain non-ADA assets.
+     */
+    LargestFirst = 0,
+    /**
+     * Performs CIP2's Random Improve ada-only selection. Will error if outputs contain non-ADA assets.
+     */
+    RandomImprove = 1,
+    /**
+     * Same as LargestFirst, but before adding ADA, will insert by largest-first for each asset type.
+     */
+    LargestFirstMultiAsset = 2,
+    /**
+     * Same as RandomImprove, but before adding ADA, will insert by random-improve for each asset type.
+     */
+    RandomImproveMultiAsset = 3,
+}
+
+export class Committee {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add_member(committee_cold_credential: Credential, epoch: number): void;
+    static from_bytes(bytes: Uint8Array): Committee;
+    static from_hex(hex_str: string): Committee;
+    static from_json(json: string): Committee;
+    get_member_epoch(committee_cold_credential: Credential): number | undefined;
+    members_keys(): Credentials;
+    static new(quorum_threshold: UnitInterval): Committee;
+    quorum_threshold(): UnitInterval;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class CommitteeColdResign {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    anchor(): Anchor | undefined;
+    committee_cold_credential(): Credential;
+    static from_bytes(bytes: Uint8Array): CommitteeColdResign;
+    static from_hex(hex_str: string): CommitteeColdResign;
+    static from_json(json: string): CommitteeColdResign;
+    has_script_credentials(): boolean;
+    static new(committee_cold_credential: Credential): CommitteeColdResign;
+    static new_with_anchor(committee_cold_credential: Credential, anchor: Anchor): CommitteeColdResign;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class CommitteeHotAuth {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    committee_cold_credential(): Credential;
+    committee_hot_credential(): Credential;
+    static from_bytes(bytes: Uint8Array): CommitteeHotAuth;
+    static from_hex(hex_str: string): CommitteeHotAuth;
+    static from_json(json: string): CommitteeHotAuth;
+    has_script_credentials(): boolean;
+    static new(committee_cold_credential: Credential, committee_hot_credential: Credential): CommitteeHotAuth;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Constitution {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    anchor(): Anchor;
+    static from_bytes(bytes: Uint8Array): Constitution;
+    static from_hex(hex_str: string): Constitution;
+    static from_json(json: string): Constitution;
+    static new(anchor: Anchor): Constitution;
+    static new_with_script_hash(anchor: Anchor, script_hash: ScriptHash): Constitution;
+    script_hash(): ScriptHash | undefined;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class ConstrPlutusData {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    alternative(): BigNum;
+    data(): PlutusList;
+    static from_bytes(bytes: Uint8Array): ConstrPlutusData;
+    static from_hex(hex_str: string): ConstrPlutusData;
+    static new(alternative: BigNum, data: PlutusList): ConstrPlutusData;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class CostModel {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): CostModel;
+    static from_hex(hex_str: string): CostModel;
+    static from_json(json: string): CostModel;
+    get(operation: number): Int;
+    len(): number;
+    /**
+     * Creates a new CostModels instance of an unrestricted length
+     */
+    static new(): CostModel;
+    /**
+     * Sets the cost at the specified index to the specified value.
+     * In case the operation index is larger than the previous largest used index,
+     * it will fill any inbetween indexes with zeroes
+     */
+    set(operation: number, cost: Int): Int;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Costmdls {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): Costmdls;
+    static from_hex(hex_str: string): Costmdls;
+    static from_json(json: string): Costmdls;
+    get(key: Language): CostModel | undefined;
+    insert(key: Language, value: CostModel): CostModel | undefined;
+    keys(): Languages;
+    len(): number;
+    static new(): Costmdls;
+    retain_language_versions(languages: Languages): Costmdls;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export enum CredKind {
+    Key = 0,
+    Script = 1,
+}
+
+export class Credential {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): Credential;
+    static from_hex(hex_str: string): Credential;
+    static from_json(json: string): Credential;
+    static from_keyhash(hash: Ed25519KeyHash): Credential;
+    static from_scripthash(hash: ScriptHash): Credential;
+    has_script_hash(): boolean;
+    kind(): CredKind;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    to_keyhash(): Ed25519KeyHash | undefined;
+    to_scripthash(): ScriptHash | undefined;
+}
+
+export class Credentials {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a new `Credential` to the set.
+     * Returns `true` if the element was not already present in the set.
+     */
+    add(credential: Credential): boolean;
+    static from_bytes(bytes: Uint8Array): Credentials;
+    static from_hex(hex_str: string): Credentials;
+    static from_json(json: string): Credentials;
+    get(index: number): Credential;
+    len(): number;
+    static new(): Credentials;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class DNSRecordAorAAAA {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): DNSRecordAorAAAA;
+    static from_hex(hex_str: string): DNSRecordAorAAAA;
+    static from_json(json: string): DNSRecordAorAAAA;
+    static new(dns_name: string): DNSRecordAorAAAA;
+    record(): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class DNSRecordSRV {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): DNSRecordSRV;
+    static from_hex(hex_str: string): DNSRecordSRV;
+    static from_json(json: string): DNSRecordSRV;
+    static new(dns_name: string): DNSRecordSRV;
+    record(): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class DRep {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech32_str: string): DRep;
+    static from_bytes(bytes: Uint8Array): DRep;
+    static from_hex(hex_str: string): DRep;
+    static from_json(json: string): DRep;
+    kind(): DRepKind;
+    static new_always_abstain(): DRep;
+    static new_always_no_confidence(): DRep;
+    static new_from_credential(cred: Credential): DRep;
+    static new_key_hash(key_hash: Ed25519KeyHash): DRep;
+    static new_script_hash(script_hash: ScriptHash): DRep;
+    to_bech32(cip_129_format: boolean): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    to_key_hash(): Ed25519KeyHash | undefined;
+    to_script_hash(): ScriptHash | undefined;
+}
+
+export class DRepDeregistration {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coin(): BigNum;
+    static from_bytes(bytes: Uint8Array): DRepDeregistration;
+    static from_hex(hex_str: string): DRepDeregistration;
+    static from_json(json: string): DRepDeregistration;
+    has_script_credentials(): boolean;
+    static new(voting_credential: Credential, coin: BigNum): DRepDeregistration;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    voting_credential(): Credential;
+}
+
+export enum DRepKind {
+    KeyHash = 0,
+    ScriptHash = 1,
+    AlwaysAbstain = 2,
+    AlwaysNoConfidence = 3,
+}
+
+export class DRepRegistration {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    anchor(): Anchor | undefined;
+    coin(): BigNum;
+    static from_bytes(bytes: Uint8Array): DRepRegistration;
+    static from_hex(hex_str: string): DRepRegistration;
+    static from_json(json: string): DRepRegistration;
+    has_script_credentials(): boolean;
+    static new(voting_credential: Credential, coin: BigNum): DRepRegistration;
+    static new_with_anchor(voting_credential: Credential, coin: BigNum, anchor: Anchor): DRepRegistration;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    voting_credential(): Credential;
+}
+
+export class DRepUpdate {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    anchor(): Anchor | undefined;
+    static from_bytes(bytes: Uint8Array): DRepUpdate;
+    static from_hex(hex_str: string): DRepUpdate;
+    static from_json(json: string): DRepUpdate;
+    has_script_credentials(): boolean;
+    static new(voting_credential: Credential): DRepUpdate;
+    static new_with_anchor(voting_credential: Credential, anchor: Anchor): DRepUpdate;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    voting_credential(): Credential;
+}
+
+export class DRepVotingThresholds {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    committee_no_confidence(): UnitInterval;
+    committee_normal(): UnitInterval;
+    static from_bytes(bytes: Uint8Array): DRepVotingThresholds;
+    static from_hex(hex_str: string): DRepVotingThresholds;
+    static from_json(json: string): DRepVotingThresholds;
+    hard_fork_initiation(): UnitInterval;
+    motion_no_confidence(): UnitInterval;
+    static new(motion_no_confidence: UnitInterval, committee_normal: UnitInterval, committee_no_confidence: UnitInterval, update_constitution: UnitInterval, hard_fork_initiation: UnitInterval, pp_network_group: UnitInterval, pp_economic_group: UnitInterval, pp_technical_group: UnitInterval, pp_governance_group: UnitInterval, treasury_withdrawal: UnitInterval): DRepVotingThresholds;
+    pp_economic_group(): UnitInterval;
+    pp_governance_group(): UnitInterval;
+    pp_network_group(): UnitInterval;
+    pp_technical_group(): UnitInterval;
+    set_committee_no_confidence(committee_no_confidence: UnitInterval): void;
+    set_committee_normal(committee_normal: UnitInterval): void;
+    set_hard_fork_initiation(hard_fork_initiation: UnitInterval): void;
+    set_motion_no_confidence(motion_no_confidence: UnitInterval): void;
+    set_pp_economic_group(pp_economic_group: UnitInterval): void;
+    set_pp_governance_group(pp_governance_group: UnitInterval): void;
+    set_pp_network_group(pp_network_group: UnitInterval): void;
+    set_pp_technical_group(pp_technical_group: UnitInterval): void;
+    set_treasury_withdrawal(treasury_withdrawal: UnitInterval): void;
+    set_update_constitution(update_constitution: UnitInterval): void;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    treasury_withdrawal(): UnitInterval;
+    update_constitution(): UnitInterval;
+}
+
+export class DataCost {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coins_per_byte(): BigNum;
+    static new_coins_per_byte(coins_per_byte: BigNum): DataCost;
+}
+
+export class DataHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): DataHash;
+    static from_bytes(bytes: Uint8Array): DataHash;
+    static from_hex(hex: string): DataHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class DatumSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static new(datum: PlutusData): DatumSource;
+    static new_ref_input(input: TransactionInput): DatumSource;
+}
+
+export class Ed25519KeyHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): Ed25519KeyHash;
+    static from_bytes(bytes: Uint8Array): Ed25519KeyHash;
+    static from_hex(hex: string): Ed25519KeyHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class Ed25519KeyHashes {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a new `Ed25519KeyHash` to the set.
+     * Returns `true` if the element was not already present in the set.
+     */
+    add(keyhash: Ed25519KeyHash): boolean;
+    contains(elem: Ed25519KeyHash): boolean;
+    static from_bytes(bytes: Uint8Array): Ed25519KeyHashes;
+    static from_hex(hex_str: string): Ed25519KeyHashes;
+    static from_json(json: string): Ed25519KeyHashes;
+    get(index: number): Ed25519KeyHash;
+    len(): number;
+    static new(): Ed25519KeyHashes;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    to_option(): Ed25519KeyHashes | undefined;
+}
+
+export class Ed25519Signature {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech32_str: string): Ed25519Signature;
+    static from_bytes(bytes: Uint8Array): Ed25519Signature;
+    static from_hex(input: string): Ed25519Signature;
+    to_bech32(): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class EnterpriseAddress {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_address(addr: Address): EnterpriseAddress | undefined;
+    network_id(): number;
+    static new(network: number, payment: Credential): EnterpriseAddress;
+    payment_cred(): Credential;
+    to_address(): Address;
+}
+
+export class ExUnitPrices {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): ExUnitPrices;
+    static from_hex(hex_str: string): ExUnitPrices;
+    static from_json(json: string): ExUnitPrices;
+    mem_price(): UnitInterval;
+    static new(mem_price: UnitInterval, step_price: UnitInterval): ExUnitPrices;
+    step_price(): UnitInterval;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class ExUnits {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): ExUnits;
+    static from_hex(hex_str: string): ExUnits;
+    static from_json(json: string): ExUnits;
+    mem(): BigNum;
+    static new(mem: BigNum, steps: BigNum): ExUnits;
+    steps(): BigNum;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+/**
+ * Read only view of a block with more strict structs for hash sensitive structs.
+ * Warning: This is experimental and may be removed or changed in the future.
+ */
+export class FixedBlock {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    auxiliary_data_set(): AuxiliaryDataSet;
+    block_hash(): BlockHash;
+    static from_bytes(bytes: Uint8Array): FixedBlock;
+    static from_hex(hex_str: string): FixedBlock;
+    header(): Header;
+    invalid_transactions(): Uint32Array;
+    transaction_bodies(): FixedTransactionBodies;
+    transaction_witness_sets(): TransactionWitnessSets;
+}
+
+export class FixedTransaction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add_bootstrap_witness(bootstrap_witness: BootstrapWitness): void;
+    add_vkey_witness(vkey_witness: Vkeywitness): void;
+    auxiliary_data(): AuxiliaryData | undefined;
+    body(): TransactionBody;
+    static from_bytes(bytes: Uint8Array): FixedTransaction;
+    static from_hex(hex_str: string): FixedTransaction;
+    is_valid(): boolean;
+    static new(raw_body: Uint8Array, raw_witness_set: Uint8Array, is_valid: boolean): FixedTransaction;
+    static new_from_body_bytes(raw_body: Uint8Array): FixedTransaction;
+    static new_with_auxiliary(raw_body: Uint8Array, raw_witness_set: Uint8Array, raw_auxiliary_data: Uint8Array, is_valid: boolean): FixedTransaction;
+    raw_auxiliary_data(): Uint8Array | undefined;
+    raw_body(): Uint8Array;
+    raw_witness_set(): Uint8Array;
+    set_auxiliary_data(raw_auxiliary_data: Uint8Array): void;
+    set_body(raw_body: Uint8Array): void;
+    set_is_valid(valid: boolean): void;
+    /**
+     * We do not recommend using this function, since it might lead to script integrity hash.
+     * The only purpose of this struct is to sign the transaction from third-party sources.
+     * Use `.sign_and_add_vkey_signature` or `.sign_and_add_icarus_bootstrap_signature` or `.sign_and_add_daedalus_bootstrap_signature` instead.
+     */
+    set_witness_set(raw_witness_set: Uint8Array): void;
+    sign_and_add_daedalus_bootstrap_signature(addr: ByronAddress, private_key: LegacyDaedalusPrivateKey): void;
+    sign_and_add_icarus_bootstrap_signature(addr: ByronAddress, private_key: Bip32PrivateKey): void;
+    sign_and_add_vkey_signature(private_key: PrivateKey): void;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    transaction_hash(): TransactionHash;
+    witness_set(): TransactionWitnessSet;
+}
+
+/**
+ * Warning: This is experimental and may be removed or changed in the future.
+ */
+export class FixedTransactionBodies {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: FixedTransactionBody): void;
+    static from_bytes(bytes: Uint8Array): FixedTransactionBodies;
+    static from_hex(hex_str: string): FixedTransactionBodies;
+    get(index: number): FixedTransactionBody;
+    len(): number;
+    static new(): FixedTransactionBodies;
+}
+
+/**
+ * Read-only view of a transaction body. With correct hash and original bytes.
+ * Warning: This is experimental and may be removed in the future.
+ */
+export class FixedTransactionBody {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): FixedTransactionBody;
+    static from_hex(hex_str: string): FixedTransactionBody;
+    original_bytes(): Uint8Array;
+    transaction_body(): TransactionBody;
+    tx_hash(): TransactionHash;
+}
+
+/**
+ * A set of witnesses for a transaction.
+ * Keeps original bytes to allow for safe roundtrip serialization.
+ * That helps to avoid incorrect script data hash after adding a  vkey or bootstrap witness.
+ * You can add a vkey witness or a bootstrap witness to the set.
+ * Or get TransactionWitnessSet to read fields.
+ */
+export class FixedTxWitnessesSet {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add_bootstrap_witness(bootstrap_witness: BootstrapWitness): void;
+    add_vkey_witness(vkey_witness: Vkeywitness): void;
+    static from_bytes(data: Uint8Array): FixedTxWitnessesSet;
+    to_bytes(): Uint8Array;
+    tx_witnesses_set(): TransactionWitnessSet;
+}
+
+/**
+ * Warning: This is experimental and may be removed in the future.
+ */
+export class FixedVersionedBlock {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    block(): FixedBlock;
+    era(): BlockEra;
+    static from_bytes(bytes: Uint8Array): FixedVersionedBlock;
+    static from_hex(hex_str: string): FixedVersionedBlock;
+}
+
+export class GeneralTransactionMetadata {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): GeneralTransactionMetadata;
+    static from_hex(hex_str: string): GeneralTransactionMetadata;
+    static from_json(json: string): GeneralTransactionMetadata;
+    get(key: BigNum): TransactionMetadatum | undefined;
+    insert(key: BigNum, value: TransactionMetadatum): TransactionMetadatum | undefined;
+    keys(): TransactionMetadatumLabels;
+    len(): number;
+    static new(): GeneralTransactionMetadata;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class GenesisDelegateHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): GenesisDelegateHash;
+    static from_bytes(bytes: Uint8Array): GenesisDelegateHash;
+    static from_hex(hex: string): GenesisDelegateHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class GenesisHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): GenesisHash;
+    static from_bytes(bytes: Uint8Array): GenesisHash;
+    static from_hex(hex: string): GenesisHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class GenesisHashes {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: GenesisHash): void;
+    static from_bytes(bytes: Uint8Array): GenesisHashes;
+    static from_hex(hex_str: string): GenesisHashes;
+    static from_json(json: string): GenesisHashes;
+    get(index: number): GenesisHash;
+    len(): number;
+    static new(): GenesisHashes;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class GenesisKeyDelegation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): GenesisKeyDelegation;
+    static from_hex(hex_str: string): GenesisKeyDelegation;
+    static from_json(json: string): GenesisKeyDelegation;
+    genesis_delegate_hash(): GenesisDelegateHash;
+    genesishash(): GenesisHash;
+    static new(genesishash: GenesisHash, genesis_delegate_hash: GenesisDelegateHash, vrf_keyhash: VRFKeyHash): GenesisKeyDelegation;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    vrf_keyhash(): VRFKeyHash;
+}
+
+export class GovernanceAction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_hard_fork_initiation_action(): HardForkInitiationAction | undefined;
+    as_info_action(): InfoAction | undefined;
+    as_new_committee_action(): UpdateCommitteeAction | undefined;
+    as_new_constitution_action(): NewConstitutionAction | undefined;
+    as_no_confidence_action(): NoConfidenceAction | undefined;
+    as_parameter_change_action(): ParameterChangeAction | undefined;
+    as_treasury_withdrawals_action(): TreasuryWithdrawalsAction | undefined;
+    static from_bytes(bytes: Uint8Array): GovernanceAction;
+    static from_hex(hex_str: string): GovernanceAction;
+    static from_json(json: string): GovernanceAction;
+    kind(): GovernanceActionKind;
+    static new_hard_fork_initiation_action(hard_fork_initiation_action: HardForkInitiationAction): GovernanceAction;
+    static new_info_action(info_action: InfoAction): GovernanceAction;
+    static new_new_committee_action(new_committee_action: UpdateCommitteeAction): GovernanceAction;
+    static new_new_constitution_action(new_constitution_action: NewConstitutionAction): GovernanceAction;
+    static new_no_confidence_action(no_confidence_action: NoConfidenceAction): GovernanceAction;
+    static new_parameter_change_action(parameter_change_action: ParameterChangeAction): GovernanceAction;
+    static new_treasury_withdrawals_action(treasury_withdrawals_action: TreasuryWithdrawalsAction): GovernanceAction;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class GovernanceActionId {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): GovernanceActionId;
+    static from_hex(hex_str: string): GovernanceActionId;
+    static from_json(json: string): GovernanceActionId;
+    index(): number;
+    static new(transaction_id: TransactionHash, index: number): GovernanceActionId;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    transaction_id(): TransactionHash;
+}
+
+export class GovernanceActionIds {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(governance_action_id: GovernanceActionId): void;
+    static from_json(json: string): GovernanceActionIds;
+    get(index: number): GovernanceActionId | undefined;
+    len(): number;
+    static new(): GovernanceActionIds;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export enum GovernanceActionKind {
+    ParameterChangeAction = 0,
+    HardForkInitiationAction = 1,
+    TreasuryWithdrawalsAction = 2,
+    NoConfidenceAction = 3,
+    UpdateCommitteeAction = 4,
+    NewConstitutionAction = 5,
+    InfoAction = 6,
+}
+
+export class HardForkInitiationAction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): HardForkInitiationAction;
+    static from_hex(hex_str: string): HardForkInitiationAction;
+    static from_json(json: string): HardForkInitiationAction;
+    gov_action_id(): GovernanceActionId | undefined;
+    static new(protocol_version: ProtocolVersion): HardForkInitiationAction;
+    static new_with_action_id(gov_action_id: GovernanceActionId, protocol_version: ProtocolVersion): HardForkInitiationAction;
+    protocol_version(): ProtocolVersion;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Header {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    body_signature(): KESSignature;
+    static from_bytes(bytes: Uint8Array): Header;
+    static from_hex(hex_str: string): Header;
+    static from_json(json: string): Header;
+    header_body(): HeaderBody;
+    static new(header_body: HeaderBody, body_signature: KESSignature): Header;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class HeaderBody {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    block_body_hash(): BlockHash;
+    block_body_size(): number;
+    block_number(): number;
+    static from_bytes(bytes: Uint8Array): HeaderBody;
+    static from_hex(hex_str: string): HeaderBody;
+    static from_json(json: string): HeaderBody;
+    /**
+     * If this function returns true, the `.nonce_vrf_or_nothing`
+     * and the `.leader_vrf_or_nothing` functions will return
+     * non-empty results
+     */
+    has_nonce_and_leader_vrf(): boolean;
+    /**
+     * If this function returns true, the `.vrf_result_or_nothing`
+     * function will return a non-empty result
+     */
+    has_vrf_result(): boolean;
+    issuer_vkey(): Vkey;
+    /**
+     * Might return nothing in case `.has_nonce_and_leader_vrf` returns false
+     */
+    leader_vrf_or_nothing(): VRFCert | undefined;
+    /**
+     * !!! DEPRECATED !!!
+     * This constructor uses outdated slot number format.
+     * Use `.new_headerbody` instead
+     */
+    static new(block_number: number, slot: number, prev_hash: BlockHash | null | undefined, issuer_vkey: Vkey, vrf_vkey: VRFVKey, vrf_result: VRFCert, block_body_size: number, block_body_hash: BlockHash, operational_cert: OperationalCert, protocol_version: ProtocolVersion): HeaderBody;
+    static new_headerbody(block_number: number, slot: BigNum, prev_hash: BlockHash | null | undefined, issuer_vkey: Vkey, vrf_vkey: VRFVKey, vrf_result: VRFCert, block_body_size: number, block_body_hash: BlockHash, operational_cert: OperationalCert, protocol_version: ProtocolVersion): HeaderBody;
+    /**
+     * Might return nothing in case `.has_nonce_and_leader_vrf` returns false
+     */
+    nonce_vrf_or_nothing(): VRFCert | undefined;
+    operational_cert(): OperationalCert;
+    prev_hash(): BlockHash | undefined;
+    protocol_version(): ProtocolVersion;
+    /**
+     * !!! DEPRECATED !!!
+     * Returns a Slot32 (u32) value in case the underlying original BigNum (u64) value is within the limits.
+     * Otherwise will just raise an error.
+     */
+    slot(): number;
+    slot_bignum(): BigNum;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    /**
+     * Might return nothing in case `.has_vrf_result` returns false
+     */
+    vrf_result_or_nothing(): VRFCert | undefined;
+    vrf_vkey(): VRFVKey;
+}
+
+export class InfoAction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static new(): InfoAction;
+}
+
+export class Int {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * !!! DEPRECATED !!!
+     * Returns an i32 value in case the underlying original i128 value is within the limits.
+     * Otherwise will just return an empty value (undefined).
+     */
+    as_i32(): number | undefined;
+    /**
+     * Returns the underlying value converted to i32 if possible (within limits)
+     * JsError in case of out of boundary overflow
+     */
+    as_i32_or_fail(): number;
+    /**
+     * Returns the underlying value converted to i32 if possible (within limits)
+     * Otherwise will just return an empty value (undefined).
+     */
+    as_i32_or_nothing(): number | undefined;
+    /**
+     * BigNum can only contain unsigned u64 values
+     *
+     * This function will return the *absolute* BigNum representation
+     * only in case the underlying i128 value is negative.
+     *
+     * Otherwise nothing will be returned (undefined).
+     */
+    as_negative(): BigNum | undefined;
+    /**
+     * BigNum can only contain unsigned u64 values
+     *
+     * This function will return the BigNum representation
+     * only in case the underlying i128 value is positive.
+     *
+     * Otherwise nothing will be returned (undefined).
+     */
+    as_positive(): BigNum | undefined;
+    static from_bytes(bytes: Uint8Array): Int;
+    static from_hex(hex_str: string): Int;
+    static from_json(json: string): Int;
+    static from_str(string: string): Int;
+    is_positive(): boolean;
+    static new(x: BigNum): Int;
+    static new_i32(x: number): Int;
+    static new_negative(x: BigNum): Int;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    /**
+     * Returns string representation of the underlying i128 value directly.
+     * Might contain the minus sign (-) in case of negative value.
+     */
+    to_str(): string;
+}
+
+export class Ipv4 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): Ipv4;
+    static from_hex(hex_str: string): Ipv4;
+    static from_json(json: string): Ipv4;
+    ip(): Uint8Array;
+    static new(data: Uint8Array): Ipv4;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Ipv6 {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): Ipv6;
+    static from_hex(hex_str: string): Ipv6;
+    static from_json(json: string): Ipv6;
+    ip(): Uint8Array;
+    static new(data: Uint8Array): Ipv6;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class KESSignature {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): KESSignature;
+    to_bytes(): Uint8Array;
+}
+
+export class KESVKey {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): KESVKey;
+    static from_bytes(bytes: Uint8Array): KESVKey;
+    static from_hex(hex: string): KESVKey;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class Language {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): Language;
+    static from_hex(hex_str: string): Language;
+    static from_json(json: string): Language;
+    kind(): LanguageKind;
+    static new_plutus_v1(): Language;
+    static new_plutus_v2(): Language;
+    static new_plutus_v3(): Language;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export enum LanguageKind {
+    PlutusV1 = 0,
+    PlutusV2 = 1,
+    PlutusV3 = 2,
+}
+
+export class Languages {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: Language): void;
+    get(index: number): Language;
+    len(): number;
+    static list(): Languages;
+    static new(): Languages;
+}
+
+export class LegacyDaedalusPrivateKey {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_bytes(): Uint8Array;
+    chaincode(): Uint8Array;
+    static from_bytes(bytes: Uint8Array): LegacyDaedalusPrivateKey;
+}
+
+export class LinearFee {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coefficient(): BigNum;
+    constant(): BigNum;
+    static new(coefficient: BigNum, constant: BigNum): LinearFee;
+}
+
+export enum MIRKind {
+    ToOtherPot = 0,
+    ToStakeCredentials = 1,
+}
+
+export enum MIRPot {
+    Reserves = 0,
+    Treasury = 1,
+}
+
+export class MIRToStakeCredentials {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): MIRToStakeCredentials;
+    static from_hex(hex_str: string): MIRToStakeCredentials;
+    static from_json(json: string): MIRToStakeCredentials;
+    get(cred: Credential): Int | undefined;
+    insert(cred: Credential, delta: Int): Int | undefined;
+    keys(): Credentials;
+    len(): number;
+    static new(): MIRToStakeCredentials;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class MalformedAddress {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_address(addr: Address): MalformedAddress | undefined;
+    original_bytes(): Uint8Array;
+    to_address(): Address;
+}
+
+export enum MetadataJsonSchema {
+    NoConversions = 0,
+    BasicConversions = 1,
+    DetailedSchema = 2,
+}
+
+export class MetadataList {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: TransactionMetadatum): void;
+    static from_bytes(bytes: Uint8Array): MetadataList;
+    static from_hex(hex_str: string): MetadataList;
+    get(index: number): TransactionMetadatum;
+    len(): number;
+    static new(): MetadataList;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class MetadataMap {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): MetadataMap;
+    static from_hex(hex_str: string): MetadataMap;
+    get(key: TransactionMetadatum): TransactionMetadatum;
+    get_i32(key: number): TransactionMetadatum;
+    get_str(key: string): TransactionMetadatum;
+    has(key: TransactionMetadatum): boolean;
+    insert(key: TransactionMetadatum, value: TransactionMetadatum): TransactionMetadatum | undefined;
+    insert_i32(key: number, value: TransactionMetadatum): TransactionMetadatum | undefined;
+    insert_str(key: string, value: TransactionMetadatum): TransactionMetadatum | undefined;
+    keys(): MetadataList;
+    len(): number;
+    static new(): MetadataMap;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class Mint {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Returns the multiasset where only negative (burning) entries are present
+     */
+    as_negative_multiasset(): MultiAsset;
+    /**
+     * Returns the multiasset where only positive (minting) entries are present
+     */
+    as_positive_multiasset(): MultiAsset;
+    static from_bytes(bytes: Uint8Array): Mint;
+    static from_hex(hex_str: string): Mint;
+    static from_json(json: string): Mint;
+    get(key: ScriptHash): MintsAssets | undefined;
+    insert(key: ScriptHash, value: MintAssets): MintAssets | undefined;
+    keys(): ScriptHashes;
+    len(): number;
+    static new(): Mint;
+    static new_from_entry(key: ScriptHash, value: MintAssets): Mint;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class MintAssets {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    get(key: AssetName): Int | undefined;
+    insert(key: AssetName, value: Int): Int | undefined;
+    keys(): AssetNames;
+    len(): number;
+    static new(): MintAssets;
+    static new_from_entry(key: AssetName, value: Int): MintAssets;
+}
+
+export class MintBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add_asset(mint: MintWitness, asset_name: AssetName, amount: Int): void;
+    build(): Mint;
+    get_native_scripts(): NativeScripts;
+    get_plutus_witnesses(): PlutusWitnesses;
+    get_redeemers(): Redeemers;
+    get_ref_inputs(): TransactionInputs;
+    has_native_scripts(): boolean;
+    has_plutus_scripts(): boolean;
+    static new(): MintBuilder;
+    set_asset(mint: MintWitness, asset_name: AssetName, amount: Int): void;
+}
+
+export class MintWitness {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static new_native_script(native_script: NativeScriptSource): MintWitness;
+    static new_plutus_script(plutus_script: PlutusScriptSource, redeemer: Redeemer): MintWitness;
+}
+
+export class MintsAssets {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(mint_assets: MintAssets): void;
+    static from_json(json: string): MintsAssets;
+    get(index: number): MintAssets | undefined;
+    len(): number;
+    static new(): MintsAssets;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class MoveInstantaneousReward {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_to_other_pot(): BigNum | undefined;
+    as_to_stake_creds(): MIRToStakeCredentials | undefined;
+    static from_bytes(bytes: Uint8Array): MoveInstantaneousReward;
+    static from_hex(hex_str: string): MoveInstantaneousReward;
+    static from_json(json: string): MoveInstantaneousReward;
+    kind(): MIRKind;
+    static new_to_other_pot(pot: MIRPot, amount: BigNum): MoveInstantaneousReward;
+    static new_to_stake_creds(pot: MIRPot, amounts: MIRToStakeCredentials): MoveInstantaneousReward;
+    pot(): MIRPot;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class MoveInstantaneousRewardsCert {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): MoveInstantaneousRewardsCert;
+    static from_hex(hex_str: string): MoveInstantaneousRewardsCert;
+    static from_json(json: string): MoveInstantaneousRewardsCert;
+    move_instantaneous_reward(): MoveInstantaneousReward;
+    static new(move_instantaneous_reward: MoveInstantaneousReward): MoveInstantaneousRewardsCert;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class MultiAsset {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): MultiAsset;
+    static from_hex(hex_str: string): MultiAsset;
+    static from_json(json: string): MultiAsset;
+    /**
+     * all assets under {policy_id}, if any exist, or else None (undefined in JS)
+     */
+    get(policy_id: ScriptHash): Assets | undefined;
+    /**
+     * returns the amount of asset {asset_name} under policy {policy_id}
+     * If such an asset does not exist, 0 is returned.
+     */
+    get_asset(policy_id: ScriptHash, asset_name: AssetName): BigNum;
+    /**
+     * set (and replace if it exists) all assets with policy {policy_id} to a copy of {assets}
+     */
+    insert(policy_id: ScriptHash, assets: Assets): Assets | undefined;
+    /**
+     * returns all policy IDs used by assets in this multiasset
+     */
+    keys(): ScriptHashes;
+    /**
+     * the number of unique policy IDs in the multiasset
+     */
+    len(): number;
+    static new(): MultiAsset;
+    /**
+     * sets the asset {asset_name} to {value} under policy {policy_id}
+     * returns the previous amount if it was set, or else None (undefined in JS)
+     */
+    set_asset(policy_id: ScriptHash, asset_name: AssetName, value: BigNum): BigNum | undefined;
+    /**
+     * removes an asset from the list if the result is 0 or less
+     * does not modify this object, instead the result is returned
+     */
+    sub(rhs_ma: MultiAsset): MultiAsset;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class MultiHostName {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    dns_name(): DNSRecordSRV;
+    static from_bytes(bytes: Uint8Array): MultiHostName;
+    static from_hex(hex_str: string): MultiHostName;
+    static from_json(json: string): MultiHostName;
+    static new(dns_name: DNSRecordSRV): MultiHostName;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class NativeScript {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_script_all(): ScriptAll | undefined;
+    as_script_any(): ScriptAny | undefined;
+    as_script_n_of_k(): ScriptNOfK | undefined;
+    as_script_pubkey(): ScriptPubkey | undefined;
+    as_timelock_expiry(): TimelockExpiry | undefined;
+    as_timelock_start(): TimelockStart | undefined;
+    static from_bytes(bytes: Uint8Array): NativeScript;
+    static from_hex(hex_str: string): NativeScript;
+    static from_json(json: string): NativeScript;
+    /**
+     * Returns a set of Ed25519KeyHashes
+     * contained within this script recursively on any depth level.
+     * The order of the keys in the result is not determined in any way.
+     */
+    get_required_signers(): Ed25519KeyHashes;
+    hash(): ScriptHash;
+    kind(): NativeScriptKind;
+    static new_script_all(script_all: ScriptAll): NativeScript;
+    static new_script_any(script_any: ScriptAny): NativeScript;
+    static new_script_n_of_k(script_n_of_k: ScriptNOfK): NativeScript;
+    static new_script_pubkey(script_pubkey: ScriptPubkey): NativeScript;
+    static new_timelock_expiry(timelock_expiry: TimelockExpiry): NativeScript;
+    static new_timelock_start(timelock_start: TimelockStart): NativeScript;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export enum NativeScriptKind {
+    ScriptPubkey = 0,
+    ScriptAll = 1,
+    ScriptAny = 2,
+    ScriptNOfK = 3,
+    TimelockStart = 4,
+    TimelockExpiry = 5,
+}
+
+export class NativeScriptSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    get_ref_script_size(): number | undefined;
+    static new(script: NativeScript): NativeScriptSource;
+    static new_ref_input(script_hash: ScriptHash, input: TransactionInput, script_size: number): NativeScriptSource;
+    set_required_signers(key_hashes: Ed25519KeyHashes): void;
+}
+
+export class NativeScripts {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: NativeScript): void;
+    static from_bytes(bytes: Uint8Array): NativeScripts;
+    static from_hex(hex_str: string): NativeScripts;
+    static from_json(json: string): NativeScripts;
+    get(index: number): NativeScript;
+    len(): number;
+    static new(): NativeScripts;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class NetworkId {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): NetworkId;
+    static from_hex(hex_str: string): NetworkId;
+    static from_json(json: string): NetworkId;
+    kind(): NetworkIdKind;
+    static mainnet(): NetworkId;
+    static testnet(): NetworkId;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export enum NetworkIdKind {
+    Testnet = 0,
+    Mainnet = 1,
+}
+
+export class NetworkInfo {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static mainnet(): NetworkInfo;
+    network_id(): number;
+    static new(network_id: number, protocol_magic: number): NetworkInfo;
+    protocol_magic(): number;
+    static testnet_preprod(): NetworkInfo;
+    static testnet_preview(): NetworkInfo;
+}
+
+export class NewConstitutionAction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    constitution(): Constitution;
+    static from_bytes(bytes: Uint8Array): NewConstitutionAction;
+    static from_hex(hex_str: string): NewConstitutionAction;
+    static from_json(json: string): NewConstitutionAction;
+    gov_action_id(): GovernanceActionId | undefined;
+    has_script_hash(): boolean;
+    static new(constitution: Constitution): NewConstitutionAction;
+    static new_with_action_id(gov_action_id: GovernanceActionId, constitution: Constitution): NewConstitutionAction;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class NoConfidenceAction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): NoConfidenceAction;
+    static from_hex(hex_str: string): NoConfidenceAction;
+    static from_json(json: string): NoConfidenceAction;
+    gov_action_id(): GovernanceActionId | undefined;
+    static new(): NoConfidenceAction;
+    static new_with_action_id(gov_action_id: GovernanceActionId): NoConfidenceAction;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Nonce {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): Nonce;
+    static from_hex(hex_str: string): Nonce;
+    static from_json(json: string): Nonce;
+    get_hash(): Uint8Array | undefined;
+    static new_from_hash(hash: Uint8Array): Nonce;
+    static new_identity(): Nonce;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class OperationalCert {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): OperationalCert;
+    static from_hex(hex_str: string): OperationalCert;
+    static from_json(json: string): OperationalCert;
+    hot_vkey(): KESVKey;
+    kes_period(): number;
+    static new(hot_vkey: KESVKey, sequence_number: number, kes_period: number, sigma: Ed25519Signature): OperationalCert;
+    sequence_number(): number;
+    sigma(): Ed25519Signature;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class OutputDatum {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    data(): PlutusData | undefined;
+    data_hash(): DataHash | undefined;
+    static new_data(data: PlutusData): OutputDatum;
+    static new_data_hash(data_hash: DataHash): OutputDatum;
+}
+
+export class ParameterChangeAction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): ParameterChangeAction;
+    static from_hex(hex_str: string): ParameterChangeAction;
+    static from_json(json: string): ParameterChangeAction;
+    gov_action_id(): GovernanceActionId | undefined;
+    static new(protocol_param_updates: ProtocolParamUpdate): ParameterChangeAction;
+    static new_with_action_id(gov_action_id: GovernanceActionId, protocol_param_updates: ProtocolParamUpdate): ParameterChangeAction;
+    static new_with_policy_hash(protocol_param_updates: ProtocolParamUpdate, policy_hash: ScriptHash): ParameterChangeAction;
+    static new_with_policy_hash_and_action_id(gov_action_id: GovernanceActionId, protocol_param_updates: ProtocolParamUpdate, policy_hash: ScriptHash): ParameterChangeAction;
+    policy_hash(): ScriptHash | undefined;
+    protocol_param_updates(): ProtocolParamUpdate;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class PlutusData {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_address(network: NetworkInfo): Address;
+    as_bytes(): Uint8Array | undefined;
+    as_constr_plutus_data(): ConstrPlutusData | undefined;
+    as_integer(): BigInt | undefined;
+    as_list(): PlutusList | undefined;
+    as_map(): PlutusMap | undefined;
+    static from_address(address: Address): PlutusData;
+    static from_bytes(bytes: Uint8Array): PlutusData;
+    static from_hex(hex_str: string): PlutusData;
+    static from_json(json: string, schema: PlutusDatumSchema): PlutusData;
+    kind(): PlutusDataKind;
+    static new_bytes(bytes: Uint8Array): PlutusData;
+    static new_constr_plutus_data(constr_plutus_data: ConstrPlutusData): PlutusData;
+    /**
+     * Same as `.new_constr_plutus_data` but creates constr with empty data list
+     */
+    static new_empty_constr_plutus_data(alternative: BigNum): PlutusData;
+    static new_integer(integer: BigInt): PlutusData;
+    static new_list(list: PlutusList): PlutusData;
+    static new_map(map: PlutusMap): PlutusData;
+    static new_single_value_constr_plutus_data(alternative: BigNum, plutus_data: PlutusData): PlutusData;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_json(schema: PlutusDatumSchema): string;
+}
+
+export enum PlutusDataKind {
+    ConstrPlutusData = 0,
+    Map = 1,
+    List = 2,
+    Integer = 3,
+    Bytes = 4,
+}
+
+/**
+ * JSON <-> PlutusData conversion schemas.
+ * Follows ScriptDataJsonSchema in cardano-cli defined at:
+ * https://github.com/input-output-hk/cardano-node/blob/master/cardano-api/src/Cardano/Api/ScriptData.hs#L254
+ *
+ * All methods here have the following restrictions due to limitations on dependencies:
+ * * JSON numbers above u64::MAX (positive) or below i64::MIN (negative) will throw errors
+ * * Hex strings for bytes don't accept odd-length (half-byte) strings.
+ *      cardano-cli seems to support these however but it seems to be different than just 0-padding
+ *      on either side when tested so proceed with caution
+ */
+export enum PlutusDatumSchema {
+    /**
+     * ScriptDataJsonNoSchema in cardano-node.
+     *
+     * This is the format used by --script-data-value in cardano-cli
+     * This tries to accept most JSON but does not support the full spectrum of Plutus datums.
+     * From JSON:
+     * * null/true/false/floats NOT supported
+     * * strings starting with 0x are treated as hex bytes. All other strings are encoded as their utf8 bytes.
+     * To JSON:
+     * * ConstrPlutusData not supported in ANY FORM (neither keys nor values)
+     * * Lists not supported in keys
+     * * Maps not supported in keys
+     */
+    BasicConversions = 0,
+    /**
+     * ScriptDataJsonDetailedSchema in cardano-node.
+     *
+     * This is the format used by --script-data-file in cardano-cli
+     * This covers almost all (only minor exceptions) Plutus datums, but the JSON must conform to a strict schema.
+     * The schema specifies that ALL keys and ALL values must be contained in a JSON map with 2 cases:
+     * 1. For ConstrPlutusData there must be two fields "constructor" contianing a number and "fields" containing its fields
+     *    e.g. { "constructor": 2, "fields": [{"int": 2}, {"list": [{"bytes": "CAFEF00D"}]}]}
+     * 2. For all other cases there must be only one field named "int", "bytes", "list" or "map"
+     *    Integer's value is a JSON number e.g. {"int": 100}
+     *    Bytes' value is a hex string representing the bytes WITHOUT any prefix e.g. {"bytes": "CAFEF00D"}
+     *    Lists' value is a JSON list of its elements encoded via the same schema e.g. {"list": [{"bytes": "CAFEF00D"}]}
+     *    Maps' value is a JSON list of objects, one for each key-value pair in the map, with keys "k" and "v"
+     *          respectively with their values being the plutus datum encoded via this same schema
+     *          e.g. {"map": [
+     *              {"k": {"int": 2}, "v": {"int": 5}},
+     *              {"k": {"map": [{"k": {"list": [{"int": 1}]}, "v": {"bytes": "FF03"}}]}, "v": {"list": []}}
+     *          ]}
+     * From JSON:
+     * * null/true/false/floats NOT supported
+     * * the JSON must conform to a very specific schema
+     * To JSON:
+     * * all Plutus datums should be fully supported outside of the integer range limitations outlined above.
+     */
+    DetailedSchema = 1,
+}
+
+export class PlutusList {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: PlutusData): void;
+    static from_bytes(bytes: Uint8Array): PlutusList;
+    static from_hex(hex_str: string): PlutusList;
+    get(index: number): PlutusData;
+    len(): number;
+    static new(): PlutusList;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class PlutusMap {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): PlutusMap;
+    static from_hex(hex_str: string): PlutusMap;
+    get(key: PlutusData): PlutusMapValues | undefined;
+    /**
+     * Returns the previous value associated with the key, if any.
+     * Replace the values associated with the key.
+     */
+    insert(key: PlutusData, values: PlutusMapValues): PlutusMapValues | undefined;
+    keys(): PlutusList;
+    /**
+     * Return count ok different keys in the map.
+     */
+    len(): number;
+    static new(): PlutusMap;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class PlutusMapValues {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: PlutusData): void;
+    get(index: number): PlutusData | undefined;
+    len(): number;
+    static new(): PlutusMapValues;
+}
+
+export class PlutusScript {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     *
+     *     * The raw bytes of this compiled Plutus script.
+     *     * If you need "cborBytes" for cardano-cli use PlutusScript::to_bytes() instead.
+     *
+     */
+    bytes(): Uint8Array;
+    static from_bytes(bytes: Uint8Array): PlutusScript;
+    /**
+     * Same as `.from_bytes` but will consider the script as requiring the Plutus Language V2
+     */
+    static from_bytes_v2(bytes: Uint8Array): PlutusScript;
+    /**
+     * Same as `.from_bytes` but will consider the script as requiring the Plutus Language V3
+     */
+    static from_bytes_v3(bytes: Uint8Array): PlutusScript;
+    /**
+     * Same as `.from_bytes` but will consider the script as requiring the specified language version
+     */
+    static from_bytes_with_version(bytes: Uint8Array, language: Language): PlutusScript;
+    static from_hex(hex_str: string): PlutusScript;
+    /**
+     * Same as .from_hex but will consider the script as requiring the specified language version
+     */
+    static from_hex_with_version(hex_str: string, language: Language): PlutusScript;
+    hash(): ScriptHash;
+    language_version(): Language;
+    /**
+     *
+     *     * Creates a new Plutus script from the RAW bytes of the compiled script.
+     *     * This does NOT include any CBOR encoding around these bytes (e.g. from "cborBytes" in cardano-cli)
+     *     * If you creating this from those you should use PlutusScript::from_bytes() instead.
+     *
+     */
+    static new(bytes: Uint8Array): PlutusScript;
+    /**
+     *
+     *     * Creates a new Plutus script from the RAW bytes of the compiled script.
+     *     * This does NOT include any CBOR encoding around these bytes (e.g. from "cborBytes" in cardano-cli)
+     *     * If you creating this from those you should use PlutusScript::from_bytes() instead.
+     *
+     */
+    static new_v2(bytes: Uint8Array): PlutusScript;
+    /**
+     *
+     *     * Creates a new Plutus script from the RAW bytes of the compiled script.
+     *     * This does NOT include any CBOR encoding around these bytes (e.g. from "cborBytes" in cardano-cli)
+     *     * If you creating this from those you should use PlutusScript::from_bytes() instead.
+     *
+     */
+    static new_v3(bytes: Uint8Array): PlutusScript;
+    /**
+     *
+     *     * Creates a new Plutus script from the RAW bytes of the compiled script.
+     *     * This does NOT include any CBOR encoding around these bytes (e.g. from "cborBytes" in cardano-cli)
+     *     * If you creating this from those you should use PlutusScript::from_bytes() instead.
+     *
+     */
+    static new_with_version(bytes: Uint8Array, language: Language): PlutusScript;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class PlutusScriptSource {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    get_ref_script_size(): number | undefined;
+    static new(script: PlutusScript): PlutusScriptSource;
+    static new_ref_input(script_hash: ScriptHash, input: TransactionInput, lang_ver: Language, script_size: number): PlutusScriptSource;
+    set_required_signers(key_hashes: Ed25519KeyHashes): void;
+}
+
+export class PlutusScripts {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: PlutusScript): void;
+    static from_bytes(bytes: Uint8Array): PlutusScripts;
+    static from_hex(hex_str: string): PlutusScripts;
+    static from_json(json: string): PlutusScripts;
+    get(index: number): PlutusScript;
+    len(): number;
+    static new(): PlutusScripts;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class PlutusWitness {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    datum(): PlutusData | undefined;
+    static new(script: PlutusScript, datum: PlutusData, redeemer: Redeemer): PlutusWitness;
+    static new_with_ref(script: PlutusScriptSource, datum: DatumSource, redeemer: Redeemer): PlutusWitness;
+    static new_with_ref_without_datum(script: PlutusScriptSource, redeemer: Redeemer): PlutusWitness;
+    static new_without_datum(script: PlutusScript, redeemer: Redeemer): PlutusWitness;
+    redeemer(): Redeemer;
+    script(): PlutusScript | undefined;
+}
+
+export class PlutusWitnesses {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: PlutusWitness): void;
+    get(index: number): PlutusWitness;
+    len(): number;
+    static new(): PlutusWitnesses;
+}
+
+export class Pointer {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cert_index(): number;
+    cert_index_bignum(): BigNum;
+    /**
+     * !!! DEPRECATED !!!
+     * This constructor uses outdated slot number format for the ttl value, tx_index and cert_index.
+     * Use `.new_pointer` instead
+     */
+    static new(slot: number, tx_index: number, cert_index: number): Pointer;
+    static new_pointer(slot: BigNum, tx_index: BigNum, cert_index: BigNum): Pointer;
+    slot(): number;
+    slot_bignum(): BigNum;
+    tx_index(): number;
+    tx_index_bignum(): BigNum;
+}
+
+export class PointerAddress {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_address(addr: Address): PointerAddress | undefined;
+    network_id(): number;
+    static new(network: number, payment: Credential, stake: Pointer): PointerAddress;
+    payment_cred(): Credential;
+    stake_pointer(): Pointer;
+    to_address(): Address;
+}
+
+export class PoolMetadata {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): PoolMetadata;
+    static from_hex(hex_str: string): PoolMetadata;
+    static from_json(json: string): PoolMetadata;
+    static new(url: URL, pool_metadata_hash: PoolMetadataHash): PoolMetadata;
+    pool_metadata_hash(): PoolMetadataHash;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    url(): URL;
+}
+
+export class PoolMetadataHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): PoolMetadataHash;
+    static from_bytes(bytes: Uint8Array): PoolMetadataHash;
+    static from_hex(hex: string): PoolMetadataHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class PoolParams {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    cost(): BigNum;
+    static from_bytes(bytes: Uint8Array): PoolParams;
+    static from_hex(hex_str: string): PoolParams;
+    static from_json(json: string): PoolParams;
+    margin(): UnitInterval;
+    static new(operator: Ed25519KeyHash, vrf_keyhash: VRFKeyHash, pledge: BigNum, cost: BigNum, margin: UnitInterval, reward_account: RewardAddress, pool_owners: Ed25519KeyHashes, relays: Relays, pool_metadata?: PoolMetadata | null): PoolParams;
+    operator(): Ed25519KeyHash;
+    pledge(): BigNum;
+    pool_metadata(): PoolMetadata | undefined;
+    pool_owners(): Ed25519KeyHashes;
+    relays(): Relays;
+    reward_account(): RewardAddress;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    vrf_keyhash(): VRFKeyHash;
+}
+
+export class PoolRegistration {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): PoolRegistration;
+    static from_hex(hex_str: string): PoolRegistration;
+    static from_json(json: string): PoolRegistration;
+    static new(pool_params: PoolParams): PoolRegistration;
+    pool_params(): PoolParams;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class PoolRetirement {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    epoch(): number;
+    static from_bytes(bytes: Uint8Array): PoolRetirement;
+    static from_hex(hex_str: string): PoolRetirement;
+    static from_json(json: string): PoolRetirement;
+    static new(pool_keyhash: Ed25519KeyHash, epoch: number): PoolRetirement;
+    pool_keyhash(): Ed25519KeyHash;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class PoolVotingThresholds {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    committee_no_confidence(): UnitInterval;
+    committee_normal(): UnitInterval;
+    static from_bytes(bytes: Uint8Array): PoolVotingThresholds;
+    static from_hex(hex_str: string): PoolVotingThresholds;
+    static from_json(json: string): PoolVotingThresholds;
+    hard_fork_initiation(): UnitInterval;
+    motion_no_confidence(): UnitInterval;
+    static new(motion_no_confidence: UnitInterval, committee_normal: UnitInterval, committee_no_confidence: UnitInterval, hard_fork_initiation: UnitInterval, security_relevant_threshold: UnitInterval): PoolVotingThresholds;
+    security_relevant_threshold(): UnitInterval;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class PrivateKey {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_bytes(): Uint8Array;
+    /**
+     * Get private key from its bech32 representation
+     * ```javascript
+     * PrivateKey.from_bech32(&#39;ed25519_sk1ahfetf02qwwg4dkq7mgp4a25lx5vh9920cr5wnxmpzz9906qvm8qwvlts0&#39;);
+     * ```
+     * For an extended 25519 key
+     * ```javascript
+     * PrivateKey.from_bech32(&#39;ed25519e_sk1gqwl4szuwwh6d0yk3nsqcc6xxc3fpvjlevgwvt60df59v8zd8f8prazt8ln3lmz096ux3xvhhvm3ca9wj2yctdh3pnw0szrma07rt5gl748fp&#39;);
+     * ```
+     */
+    static from_bech32(bech32_str: string): PrivateKey;
+    static from_extended_bytes(bytes: Uint8Array): PrivateKey;
+    static from_hex(hex_str: string): PrivateKey;
+    static from_normal_bytes(bytes: Uint8Array): PrivateKey;
+    static generate_ed25519(): PrivateKey;
+    static generate_ed25519extended(): PrivateKey;
+    sign(message: Uint8Array): Ed25519Signature;
+    to_bech32(): string;
+    to_hex(): string;
+    to_public(): PublicKey;
+}
+
+export class ProposedProtocolParameterUpdates {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): ProposedProtocolParameterUpdates;
+    static from_hex(hex_str: string): ProposedProtocolParameterUpdates;
+    static from_json(json: string): ProposedProtocolParameterUpdates;
+    get(key: GenesisHash): ProtocolParamUpdate | undefined;
+    insert(key: GenesisHash, value: ProtocolParamUpdate): ProtocolParamUpdate | undefined;
+    keys(): GenesisHashes;
+    len(): number;
+    static new(): ProposedProtocolParameterUpdates;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class ProtocolParamUpdate {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    ada_per_utxo_byte(): BigNum | undefined;
+    collateral_percentage(): number | undefined;
+    committee_term_limit(): number | undefined;
+    cost_models(): Costmdls | undefined;
+    /**
+     * !!! DEPRECATED !!!
+     * Since babbage era this param is outdated. But this param you can meet in a pre-babbage block.
+     */
+    d(): UnitInterval | undefined;
+    drep_deposit(): BigNum | undefined;
+    drep_inactivity_period(): number | undefined;
+    drep_voting_thresholds(): DRepVotingThresholds | undefined;
+    execution_costs(): ExUnitPrices | undefined;
+    expansion_rate(): UnitInterval | undefined;
+    /**
+     * !!! DEPRECATED !!!
+     * Since babbage era this param is outdated. But this param you can meet in a pre-babbage block.
+     */
+    extra_entropy(): Nonce | undefined;
+    static from_bytes(bytes: Uint8Array): ProtocolParamUpdate;
+    static from_hex(hex_str: string): ProtocolParamUpdate;
+    static from_json(json: string): ProtocolParamUpdate;
+    governance_action_deposit(): BigNum | undefined;
+    governance_action_validity_period(): number | undefined;
+    key_deposit(): BigNum | undefined;
+    max_block_body_size(): number | undefined;
+    max_block_ex_units(): ExUnits | undefined;
+    max_block_header_size(): number | undefined;
+    max_collateral_inputs(): number | undefined;
+    max_epoch(): number | undefined;
+    max_tx_ex_units(): ExUnits | undefined;
+    max_tx_size(): number | undefined;
+    max_value_size(): number | undefined;
+    min_committee_size(): number | undefined;
+    min_pool_cost(): BigNum | undefined;
+    minfee_a(): BigNum | undefined;
+    minfee_b(): BigNum | undefined;
+    n_opt(): number | undefined;
+    static new(): ProtocolParamUpdate;
+    pool_deposit(): BigNum | undefined;
+    pool_pledge_influence(): UnitInterval | undefined;
+    pool_voting_thresholds(): PoolVotingThresholds | undefined;
+    protocol_version(): ProtocolVersion | undefined;
+    ref_script_coins_per_byte(): UnitInterval | undefined;
+    set_ada_per_utxo_byte(ada_per_utxo_byte: BigNum): void;
+    set_collateral_percentage(collateral_percentage: number): void;
+    set_committee_term_limit(committee_term_limit: number): void;
+    set_cost_models(cost_models: Costmdls): void;
+    set_drep_deposit(drep_deposit: BigNum): void;
+    set_drep_inactivity_period(drep_inactivity_period: number): void;
+    set_drep_voting_thresholds(drep_voting_thresholds: DRepVotingThresholds): void;
+    set_execution_costs(execution_costs: ExUnitPrices): void;
+    set_expansion_rate(expansion_rate: UnitInterval): void;
+    set_governance_action_deposit(governance_action_deposit: BigNum): void;
+    set_governance_action_validity_period(governance_action_validity_period: number): void;
+    set_key_deposit(key_deposit: BigNum): void;
+    set_max_block_body_size(max_block_body_size: number): void;
+    set_max_block_ex_units(max_block_ex_units: ExUnits): void;
+    set_max_block_header_size(max_block_header_size: number): void;
+    set_max_collateral_inputs(max_collateral_inputs: number): void;
+    set_max_epoch(max_epoch: number): void;
+    set_max_tx_ex_units(max_tx_ex_units: ExUnits): void;
+    set_max_tx_size(max_tx_size: number): void;
+    set_max_value_size(max_value_size: number): void;
+    set_min_committee_size(min_committee_size: number): void;
+    set_min_pool_cost(min_pool_cost: BigNum): void;
+    set_minfee_a(minfee_a: BigNum): void;
+    set_minfee_b(minfee_b: BigNum): void;
+    set_n_opt(n_opt: number): void;
+    set_pool_deposit(pool_deposit: BigNum): void;
+    set_pool_pledge_influence(pool_pledge_influence: UnitInterval): void;
+    set_pool_voting_thresholds(pool_voting_thresholds: PoolVotingThresholds): void;
+    /**
+     * !!! DEPRECATED !!!
+     * Since conway era this param is outdated. But this param you can meet in a pre-conway block.
+     */
+    set_protocol_version(protocol_version: ProtocolVersion): void;
+    set_ref_script_coins_per_byte(ref_script_coins_per_byte: UnitInterval): void;
+    set_treasury_growth_rate(treasury_growth_rate: UnitInterval): void;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    treasury_growth_rate(): UnitInterval | undefined;
+}
+
+export class ProtocolVersion {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): ProtocolVersion;
+    static from_hex(hex_str: string): ProtocolVersion;
+    static from_json(json: string): ProtocolVersion;
+    major(): number;
+    minor(): number;
+    static new(major: number, minor: number): ProtocolVersion;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+/**
+ * ED25519 key used as public key
+ */
+export class PublicKey {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_bytes(): Uint8Array;
+    /**
+     * Get public key from its bech32 representation
+     * Example:
+     * ```javascript
+     * const pkey = PublicKey.from_bech32(&#39;ed25519_pk1dgaagyh470y66p899txcl3r0jaeaxu6yd7z2dxyk55qcycdml8gszkxze2&#39;);
+     * ```
+     */
+    static from_bech32(bech32_str: string): PublicKey;
+    static from_bytes(bytes: Uint8Array): PublicKey;
+    static from_hex(hex_str: string): PublicKey;
+    hash(): Ed25519KeyHash;
+    to_bech32(): string;
+    to_hex(): string;
+    verify(data: Uint8Array, signature: Ed25519Signature): boolean;
+}
+
+export class PublicKeys {
+    free(): void;
+    [Symbol.dispose](): void;
+    add(key: PublicKey): void;
+    get(index: number): PublicKey;
+    constructor();
+    size(): number;
+}
+
+export class Redeemer {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    data(): PlutusData;
+    ex_units(): ExUnits;
+    static from_bytes(bytes: Uint8Array): Redeemer;
+    static from_hex(hex_str: string): Redeemer;
+    static from_json(json: string): Redeemer;
+    index(): BigNum;
+    static new(tag: RedeemerTag, index: BigNum, data: PlutusData, ex_units: ExUnits): Redeemer;
+    tag(): RedeemerTag;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class RedeemerTag {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): RedeemerTag;
+    static from_hex(hex_str: string): RedeemerTag;
+    static from_json(json: string): RedeemerTag;
+    kind(): RedeemerTagKind;
+    static new_cert(): RedeemerTag;
+    static new_mint(): RedeemerTag;
+    static new_reward(): RedeemerTag;
+    static new_spend(): RedeemerTag;
+    static new_vote(): RedeemerTag;
+    static new_voting_proposal(): RedeemerTag;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export enum RedeemerTagKind {
+    Spend = 0,
+    Mint = 1,
+    Cert = 2,
+    Reward = 3,
+    Vote = 4,
+    VotingProposal = 5,
+}
+
+export class Redeemers {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: Redeemer): void;
+    static from_bytes(bytes: Uint8Array): Redeemers;
+    static from_hex(hex_str: string): Redeemers;
+    static from_json(json: string): Redeemers;
+    get(index: number): Redeemer;
+    /**
+     * WARNING: This function will be removed in after next hard fork
+     */
+    get_container_type(): CborContainerType;
+    len(): number;
+    static new(): Redeemers;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    total_ex_units(): ExUnits;
+}
+
+export class Relay {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_multi_host_name(): MultiHostName | undefined;
+    as_single_host_addr(): SingleHostAddr | undefined;
+    as_single_host_name(): SingleHostName | undefined;
+    static from_bytes(bytes: Uint8Array): Relay;
+    static from_hex(hex_str: string): Relay;
+    static from_json(json: string): Relay;
+    kind(): RelayKind;
+    static new_multi_host_name(multi_host_name: MultiHostName): Relay;
+    static new_single_host_addr(single_host_addr: SingleHostAddr): Relay;
+    static new_single_host_name(single_host_name: SingleHostName): Relay;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export enum RelayKind {
+    SingleHostAddr = 0,
+    SingleHostName = 1,
+    MultiHostName = 2,
+}
+
+export class Relays {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: Relay): void;
+    static from_bytes(bytes: Uint8Array): Relays;
+    static from_hex(hex_str: string): Relays;
+    static from_json(json: string): Relays;
+    get(index: number): Relay;
+    len(): number;
+    static new(): Relays;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class RewardAddress {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_address(addr: Address): RewardAddress | undefined;
+    network_id(): number;
+    static new(network: number, payment: Credential): RewardAddress;
+    payment_cred(): Credential;
+    to_address(): Address;
+}
+
+export class RewardAddresses {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: RewardAddress): void;
+    static from_bytes(bytes: Uint8Array): RewardAddresses;
+    static from_hex(hex_str: string): RewardAddresses;
+    static from_json(json: string): RewardAddresses;
+    get(index: number): RewardAddress;
+    len(): number;
+    static new(): RewardAddresses;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class ScriptAll {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): ScriptAll;
+    static from_hex(hex_str: string): ScriptAll;
+    static from_json(json: string): ScriptAll;
+    native_scripts(): NativeScripts;
+    static new(native_scripts: NativeScripts): ScriptAll;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class ScriptAny {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): ScriptAny;
+    static from_hex(hex_str: string): ScriptAny;
+    static from_json(json: string): ScriptAny;
+    native_scripts(): NativeScripts;
+    static new(native_scripts: NativeScripts): ScriptAny;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class ScriptDataHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): ScriptDataHash;
+    static from_bytes(bytes: Uint8Array): ScriptDataHash;
+    static from_hex(hex: string): ScriptDataHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class ScriptHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): ScriptHash;
+    static from_bytes(bytes: Uint8Array): ScriptHash;
+    static from_hex(hex: string): ScriptHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+/**
+ * Each new language uses a different namespace for hashing its script
+ * This is because you could have a language where the same bytes have different semantics
+ * So this avoids scripts in different languages mapping to the same hash
+ * Note that the enum value here is different than the enum value for deciding the cost model of a script
+ */
+export enum ScriptHashNamespace {
+    NativeScript = 0,
+    PlutusScript = 1,
+    PlutusScriptV2 = 2,
+    PlutusScriptV3 = 3,
+}
+
+export class ScriptHashes {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: ScriptHash): void;
+    static from_bytes(bytes: Uint8Array): ScriptHashes;
+    static from_hex(hex_str: string): ScriptHashes;
+    static from_json(json: string): ScriptHashes;
+    get(index: number): ScriptHash;
+    len(): number;
+    static new(): ScriptHashes;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class ScriptNOfK {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): ScriptNOfK;
+    static from_hex(hex_str: string): ScriptNOfK;
+    static from_json(json: string): ScriptNOfK;
+    n(): number;
+    native_scripts(): NativeScripts;
+    static new(n: number, native_scripts: NativeScripts): ScriptNOfK;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class ScriptPubkey {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    addr_keyhash(): Ed25519KeyHash;
+    static from_bytes(bytes: Uint8Array): ScriptPubkey;
+    static from_hex(hex_str: string): ScriptPubkey;
+    static from_json(json: string): ScriptPubkey;
+    static new(addr_keyhash: Ed25519KeyHash): ScriptPubkey;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class ScriptRef {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): ScriptRef;
+    static from_hex(hex_str: string): ScriptRef;
+    static from_json(json: string): ScriptRef;
+    is_native_script(): boolean;
+    is_plutus_script(): boolean;
+    native_script(): NativeScript | undefined;
+    static new_native_script(native_script: NativeScript): ScriptRef;
+    static new_plutus_script(plutus_script: PlutusScript): ScriptRef;
+    plutus_script(): PlutusScript | undefined;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    /**
+     * Return bytes array of script ref struct but without wrapping into CBOR array under the tag
+     * to_bytes returns "#6.24(bytes .cbor script)" from CDDL
+     * to_unwrapped_bytes return "script" from CDDL
+     */
+    to_unwrapped_bytes(): Uint8Array;
+}
+
+/**
+ * Used to choosed the schema for a script JSON string
+ */
+export enum ScriptSchema {
+    Wallet = 0,
+    Node = 1,
+}
+
+export class SingleHostAddr {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): SingleHostAddr;
+    static from_hex(hex_str: string): SingleHostAddr;
+    static from_json(json: string): SingleHostAddr;
+    ipv4(): Ipv4 | undefined;
+    ipv6(): Ipv6 | undefined;
+    static new(port?: number | null, ipv4?: Ipv4 | null, ipv6?: Ipv6 | null): SingleHostAddr;
+    port(): number | undefined;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class SingleHostName {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    dns_name(): DNSRecordAorAAAA;
+    static from_bytes(bytes: Uint8Array): SingleHostName;
+    static from_hex(hex_str: string): SingleHostName;
+    static from_json(json: string): SingleHostName;
+    static new(port: number | null | undefined, dns_name: DNSRecordAorAAAA): SingleHostName;
+    port(): number | undefined;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class StakeAndVoteDelegation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    drep(): DRep;
+    static from_bytes(bytes: Uint8Array): StakeAndVoteDelegation;
+    static from_hex(hex_str: string): StakeAndVoteDelegation;
+    static from_json(json: string): StakeAndVoteDelegation;
+    has_script_credentials(): boolean;
+    static new(stake_credential: Credential, pool_keyhash: Ed25519KeyHash, drep: DRep): StakeAndVoteDelegation;
+    pool_keyhash(): Ed25519KeyHash;
+    stake_credential(): Credential;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class StakeDelegation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): StakeDelegation;
+    static from_hex(hex_str: string): StakeDelegation;
+    static from_json(json: string): StakeDelegation;
+    has_script_credentials(): boolean;
+    static new(stake_credential: Credential, pool_keyhash: Ed25519KeyHash): StakeDelegation;
+    pool_keyhash(): Ed25519KeyHash;
+    stake_credential(): Credential;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class StakeDeregistration {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coin(): BigNum | undefined;
+    static from_bytes(bytes: Uint8Array): StakeDeregistration;
+    static from_hex(hex_str: string): StakeDeregistration;
+    static from_json(json: string): StakeDeregistration;
+    has_script_credentials(): boolean;
+    static new(stake_credential: Credential): StakeDeregistration;
+    static new_with_explicit_refund(stake_credential: Credential, coin: BigNum): StakeDeregistration;
+    stake_credential(): Credential;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class StakeRegistration {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coin(): BigNum | undefined;
+    static from_bytes(bytes: Uint8Array): StakeRegistration;
+    static from_hex(hex_str: string): StakeRegistration;
+    static from_json(json: string): StakeRegistration;
+    has_script_credentials(): boolean;
+    static new(stake_credential: Credential): StakeRegistration;
+    static new_with_explicit_deposit(stake_credential: Credential, coin: BigNum): StakeRegistration;
+    stake_credential(): Credential;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class StakeRegistrationAndDelegation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coin(): BigNum;
+    static from_bytes(bytes: Uint8Array): StakeRegistrationAndDelegation;
+    static from_hex(hex_str: string): StakeRegistrationAndDelegation;
+    static from_json(json: string): StakeRegistrationAndDelegation;
+    has_script_credentials(): boolean;
+    static new(stake_credential: Credential, pool_keyhash: Ed25519KeyHash, coin: BigNum): StakeRegistrationAndDelegation;
+    pool_keyhash(): Ed25519KeyHash;
+    stake_credential(): Credential;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class StakeVoteRegistrationAndDelegation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coin(): BigNum;
+    drep(): DRep;
+    static from_bytes(bytes: Uint8Array): StakeVoteRegistrationAndDelegation;
+    static from_hex(hex_str: string): StakeVoteRegistrationAndDelegation;
+    static from_json(json: string): StakeVoteRegistrationAndDelegation;
+    has_script_credentials(): boolean;
+    static new(stake_credential: Credential, pool_keyhash: Ed25519KeyHash, drep: DRep, coin: BigNum): StakeVoteRegistrationAndDelegation;
+    pool_keyhash(): Ed25519KeyHash;
+    stake_credential(): Credential;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Strings {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: string): void;
+    get(index: number): string;
+    len(): number;
+    static new(): Strings;
+}
+
+export class TimelockExpiry {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): TimelockExpiry;
+    static from_hex(hex_str: string): TimelockExpiry;
+    static from_json(json: string): TimelockExpiry;
+    /**
+     * !!! DEPRECATED !!!
+     * This constructor uses outdated slot number format.
+     * Use `.new_timelockexpiry` instead
+     */
+    static new(slot: number): TimelockExpiry;
+    static new_timelockexpiry(slot: BigNum): TimelockExpiry;
+    slot(): number;
+    slot_bignum(): BigNum;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class TimelockStart {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): TimelockStart;
+    static from_hex(hex_str: string): TimelockStart;
+    static from_json(json: string): TimelockStart;
+    /**
+     * !!! DEPRECATED !!!
+     * This constructor uses outdated slot number format.
+     * Use `.new_timelockstart` instead.
+     */
+    static new(slot: number): TimelockStart;
+    static new_timelockstart(slot: BigNum): TimelockStart;
+    /**
+     * !!! DEPRECATED !!!
+     * Returns a Slot32 (u32) value in case the underlying original BigNum (u64) value is within the limits.
+     * Otherwise will just raise an error.
+     * Use `.slot_bignum` instead
+     */
+    slot(): number;
+    slot_bignum(): BigNum;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Transaction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    auxiliary_data(): AuxiliaryData | undefined;
+    body(): TransactionBody;
+    static from_bytes(bytes: Uint8Array): Transaction;
+    static from_hex(hex_str: string): Transaction;
+    static from_json(json: string): Transaction;
+    is_valid(): boolean;
+    static new(body: TransactionBody, witness_set: TransactionWitnessSet, auxiliary_data?: AuxiliaryData | null): Transaction;
+    set_is_valid(valid: boolean): void;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    witness_set(): TransactionWitnessSet;
+}
+
+export class TransactionBatch {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    get(index: number): Transaction;
+    len(): number;
+}
+
+export class TransactionBatchList {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    get(index: number): TransactionBatch;
+    len(): number;
+}
+
+export class TransactionBodies {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: TransactionBody): void;
+    static from_bytes(bytes: Uint8Array): TransactionBodies;
+    static from_hex(hex_str: string): TransactionBodies;
+    static from_json(json: string): TransactionBodies;
+    get(index: number): TransactionBody;
+    len(): number;
+    static new(): TransactionBodies;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class TransactionBody {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    auxiliary_data_hash(): AuxiliaryDataHash | undefined;
+    certs(): Certificates | undefined;
+    collateral(): TransactionInputs | undefined;
+    collateral_return(): TransactionOutput | undefined;
+    current_treasury_value(): BigNum | undefined;
+    donation(): BigNum | undefined;
+    fee(): BigNum;
+    static from_bytes(bytes: Uint8Array): TransactionBody;
+    static from_hex(hex_str: string): TransactionBody;
+    static from_json(json: string): TransactionBody;
+    inputs(): TransactionInputs;
+    mint(): Mint | undefined;
+    network_id(): NetworkId | undefined;
+    /**
+     * !!! DEPRECATED !!!
+     * This constructor uses outdated slot number format for the ttl value.
+     * Use `.new_tx_body` and then `.set_ttl` instead
+     */
+    static new(inputs: TransactionInputs, outputs: TransactionOutputs, fee: BigNum, ttl?: number | null): TransactionBody;
+    /**
+     * Returns a new TransactionBody.
+     * In the new version of "new" we removed optional ttl for support it by wasm_bingen.
+     * Your can use "set_ttl" and "remove_ttl" to set a new value for ttl or set it as None.
+     */
+    static new_tx_body(inputs: TransactionInputs, outputs: TransactionOutputs, fee: BigNum): TransactionBody;
+    outputs(): TransactionOutputs;
+    reference_inputs(): TransactionInputs | undefined;
+    remove_ttl(): void;
+    required_signers(): Ed25519KeyHashes | undefined;
+    script_data_hash(): ScriptDataHash | undefined;
+    set_auxiliary_data_hash(auxiliary_data_hash: AuxiliaryDataHash): void;
+    set_certs(certs: Certificates): void;
+    set_collateral(collateral: TransactionInputs): void;
+    set_collateral_return(collateral_return: TransactionOutput): void;
+    set_current_treasury_value(current_treasury_value: BigNum): void;
+    set_donation(donation: BigNum): void;
+    set_mint(mint: Mint): void;
+    set_network_id(network_id: NetworkId): void;
+    set_reference_inputs(reference_inputs: TransactionInputs): void;
+    set_required_signers(required_signers: Ed25519KeyHashes): void;
+    set_script_data_hash(script_data_hash: ScriptDataHash): void;
+    set_total_collateral(total_collateral: BigNum): void;
+    set_ttl(ttl: BigNum): void;
+    set_update(update: Update): void;
+    /**
+     * !!! DEPRECATED !!!
+     * Uses outdated slot number format.
+     */
+    set_validity_start_interval(validity_start_interval: number): void;
+    set_validity_start_interval_bignum(validity_start_interval: BigNum): void;
+    set_voting_procedures(voting_procedures: VotingProcedures): void;
+    set_voting_proposals(voting_proposals: VotingProposals): void;
+    set_withdrawals(withdrawals: Withdrawals): void;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    total_collateral(): BigNum | undefined;
+    /**
+     * !!! DEPRECATED !!!
+     * Returns a Slot32 (u32) value in case the underlying original BigNum (u64) value is within the limits.
+     * Otherwise will just raise an error.
+     */
+    ttl(): number | undefined;
+    ttl_bignum(): BigNum | undefined;
+    update(): Update | undefined;
+    /**
+     * !!! DEPRECATED !!!
+     * Returns a Option<Slot32> (u32) value in case the underlying original Option<BigNum> (u64) value is within the limits.
+     * Otherwise will just raise an error.
+     * Use `.validity_start_interval_bignum` instead.
+     */
+    validity_start_interval(): number | undefined;
+    validity_start_interval_bignum(): BigNum | undefined;
+    voting_procedures(): VotingProcedures | undefined;
+    voting_proposals(): VotingProposals | undefined;
+    withdrawals(): Withdrawals | undefined;
+}
+
+export class TransactionBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add_bootstrap_input(hash: ByronAddress, input: TransactionInput, amount: Value): void;
+    /**
+     * Warning: this function will mutate the /fee/ field
+     * Make sure to call this function last after setting all other tx-body properties
+     * Editing inputs, outputs, mint, etc. after change been calculated
+     * might cause a mismatch in calculated fee versus the required fee
+     */
+    add_change_if_needed(address: Address): boolean;
+    add_change_if_needed_with_datum(address: Address, plutus_data: OutputDatum): boolean;
+    add_extra_witness_datum(datum: PlutusData): void;
+    /**
+     * This automatically selects and adds inputs from {inputs} consisting of just enough to cover
+     * the outputs that have already been added.
+     * This should be called after adding all certs/outputs/etc and will be an error otherwise.
+     * Uses CIP2: https://github.com/cardano-foundation/CIPs/blob/master/CIP-0002/CIP-0002.md
+     * Adding a change output must be called after via TransactionBuilder::add_change_if_needed()
+     * This function, diverging from CIP2, takes into account fees and will attempt to add additional
+     * inputs to cover the minimum fees. This does not, however, set the txbuilder's fee.
+     */
+    add_inputs_from(inputs: TransactionUnspentOutputs, strategy: CoinSelectionStrategyCIP2): void;
+    add_inputs_from_and_change(inputs: TransactionUnspentOutputs, strategy: CoinSelectionStrategyCIP2, change_config: ChangeConfig): boolean;
+    add_inputs_from_and_change_with_collateral_return(inputs: TransactionUnspentOutputs, strategy: CoinSelectionStrategyCIP2, change_config: ChangeConfig, collateral_percentage: BigNum): void;
+    /**
+     * Add a single JSON metadatum using a TransactionMetadatumLabel and a String
+     * It will be securely added to existing or new metadata in this builder
+     */
+    add_json_metadatum(key: BigNum, val: string): void;
+    /**
+     * Add a single JSON metadatum using a TransactionMetadatumLabel, a String, and a MetadataJsonSchema object
+     * It will be securely added to existing or new metadata in this builder
+     */
+    add_json_metadatum_with_schema(key: BigNum, val: string, schema: MetadataJsonSchema): void;
+    /**
+     * We have to know what kind of inputs these are to know what kind of mock witnesses to create since
+     * 1) mock witnesses have different lengths depending on the type which changes the expecting fee
+     * 2) Witnesses are a set so we need to get rid of duplicates to avoid over-estimating the fee
+     */
+    add_key_input(hash: Ed25519KeyHash, input: TransactionInput, amount: Value): void;
+    /**
+     * Add a single metadatum using TransactionMetadatumLabel and TransactionMetadatum objects
+     * It will be securely added to existing or new metadata in this builder
+     */
+    add_metadatum(key: BigNum, val: TransactionMetadatum): void;
+    /**
+     * !!! DEPRECATED !!!
+     * Mints are defining by MintBuilder now.
+     * Use `.set_mint_builder()` and `MintBuilder` instead.
+     * Add a mint entry to this builder using a PolicyID, AssetName, and Int object for amount
+     * It will be securely added to existing or new Mint in this builder
+     * It will replace any previous existing amount same PolicyID and AssetName
+     */
+    add_mint_asset(policy_script: NativeScript, asset_name: AssetName, amount: Int): void;
+    /**
+     * Add a mint entry together with an output to this builder
+     * Using a PolicyID, AssetName, Int for amount, Address, and Coin (BigNum) objects
+     * The asset will be securely added to existing or new Mint in this builder
+     * A new output will be added with the specified Address, the Coin value, and the minted asset
+     */
+    add_mint_asset_and_output(policy_script: NativeScript, asset_name: AssetName, amount: Int, output_builder: TransactionOutputAmountBuilder, output_coin: BigNum): void;
+    /**
+     * Add a mint entry together with an output to this builder
+     * Using a PolicyID, AssetName, Int for amount, and Address objects
+     * The asset will be securely added to existing or new Mint in this builder
+     * A new output will be added with the specified Address and the minted asset
+     * The output will be set to contain the minimum required amount of Coin
+     */
+    add_mint_asset_and_output_min_required_coin(policy_script: NativeScript, asset_name: AssetName, amount: Int, output_builder: TransactionOutputAmountBuilder): void;
+    /**
+     * This method will add the input to the builder and also register the required native script witness
+     */
+    add_native_script_input(script: NativeScript, input: TransactionInput, amount: Value): void;
+    /**
+     * Add explicit output via a TransactionOutput object
+     */
+    add_output(output: TransactionOutput): void;
+    /**
+     * This method will add the input to the builder and also register the required plutus witness
+     */
+    add_plutus_script_input(witness: PlutusWitness, input: TransactionInput, amount: Value): void;
+    add_reference_input(reference_input: TransactionInput): void;
+    /**
+     * This function is replace for previous one add_input.
+     * The functions adds a non script input, if it is a script input it returns an error.
+     * To add script input you need to use add_native_script_input or add_plutus_script_input.
+     * Also we recommend to use TxInputsBuilder and .set_inputs, because all add_*_input functions might be removed from transaction builder.
+     */
+    add_regular_input(address: Address, input: TransactionInput, amount: Value): void;
+    add_required_signer(key: Ed25519KeyHash): void;
+    add_script_reference_input(reference_input: TransactionInput, script_size: number): void;
+    /**
+     * Returns object the body of the new transaction
+     * Auxiliary data itself is not included
+     * You can use `get_auxiliary_data` or `build_tx`
+     */
+    build(): TransactionBody;
+    /**
+     * Returns full Transaction object with the body and the auxiliary data
+     * NOTE: witness_set will contain all mint_scripts if any been added or set
+     * NOTE: is_valid set to true
+     * NOTE: Will fail in case there are any script inputs added with no corresponding witness
+     */
+    build_tx(): Transaction;
+    /**
+     * Similar to `.build_tx()` but will NOT fail in case there are missing script witnesses
+     */
+    build_tx_unsafe(): Transaction;
+    /**
+     * This method will calculate the script hash data
+     * using the plutus datums and redeemers already present in the builder
+     * along with the provided cost model, and will register the calculated value
+     * in the builder to be used when building the tx body.
+     * In case there are no plutus input witnesses present - nothing will change
+     * You can set specific hash value using `.set_script_data_hash`
+     * NOTE: this function will check which language versions are used in the present scripts
+     * and will assert and require for a corresponding cost-model to be present in the passed map.
+     * Only the cost-models for the present language versions will be used in the hash calculation.
+     */
+    calc_script_data_hash(cost_models: Costmdls): void;
+    /**
+     * calculates how much the fee would increase if you added a given output
+     */
+    fee_for_input(address: Address, input: TransactionInput, amount: Value): BigNum;
+    /**
+     * calculates how much the fee would increase if you added a given output
+     */
+    fee_for_output(output: TransactionOutput): BigNum;
+    full_size(): number;
+    get_auxiliary_data(): AuxiliaryData | undefined;
+    get_current_treasury_value(): BigNum | undefined;
+    get_deposit(): BigNum;
+    get_donation(): BigNum | undefined;
+    /**
+     * does not include refunds or withdrawals
+     */
+    get_explicit_input(): Value;
+    /**
+     * does not include fee
+     */
+    get_explicit_output(): Value;
+    get_extra_witness_datums(): PlutusList | undefined;
+    get_fee_if_set(): BigNum | undefined;
+    /**
+     * withdrawals and refunds
+     */
+    get_implicit_input(): Value;
+    /**
+     * !!! DEPRECATED !!!
+     * Mints are defining by MintBuilder now.
+     * Use `.get_mint_builder()` and `.build()` instead.
+     * Returns a copy of the current mint state in the builder
+     */
+    get_mint(): Mint | undefined;
+    get_mint_builder(): MintBuilder | undefined;
+    /**
+     * Returns a copy of the current mint witness scripts in the builder
+     */
+    get_mint_scripts(): NativeScripts | undefined;
+    /**
+     * Returns a copy of the current script input witness scripts in the builder
+     */
+    get_native_input_scripts(): NativeScripts | undefined;
+    /**
+     * Returns a copy of the current plutus input witness scripts in the builder.
+     * NOTE: each plutus witness will be cloned with a specific corresponding input index
+     */
+    get_plutus_input_scripts(): PlutusWitnesses | undefined;
+    get_reference_inputs(): TransactionInputs;
+    /**
+     * Return explicit input plus implicit input plus mint
+     */
+    get_total_input(): Value;
+    /**
+     * Return explicit output plus deposit plus burn
+     */
+    get_total_output(): Value;
+    /**
+     * warning: sum of all parts of a transaction must equal 0. You cannot just set the fee to the min value and forget about it
+     * warning: min_fee may be slightly larger than the actual minimum fee (ex: a few lovelaces)
+     * this is done to simplify the library code, but can be fixed later
+     */
+    min_fee(): BigNum;
+    static new(cfg: TransactionBuilderConfig): TransactionBuilder;
+    output_sizes(): Uint32Array;
+    remove_auxiliary_data(): void;
+    remove_certs(): void;
+    remove_collateral_return(): void;
+    remove_mint_builder(): void;
+    /**
+     * Deletes any previously set plutus data hash value.
+     * Use `.set_script_data_hash` or `.calc_script_data_hash` to set it.
+     */
+    remove_script_data_hash(): void;
+    remove_total_collateral(): void;
+    remove_ttl(): void;
+    remove_validity_start_interval(): void;
+    remove_withdrawals(): void;
+    /**
+     * Set explicit auxiliary data via an AuxiliaryData object
+     * It might contain some metadata plus native or Plutus scripts
+     */
+    set_auxiliary_data(auxiliary_data: AuxiliaryData): void;
+    /**
+     * !!! DEPRECATED !!!
+     * Can emit error if add a cert with script credential.
+     * Use set_certs_builder instead.
+     */
+    set_certs(certs: Certificates): void;
+    set_certs_builder(certs: CertificatesBuilder): void;
+    set_collateral(collateral: TxInputsBuilder): void;
+    set_collateral_return(collateral_return: TransactionOutput): void;
+    /**
+     * This function will set the collateral-return value and then auto-calculate and assign
+     * the total collateral coin value. Will raise an error in case no collateral inputs are set
+     * or in case the total collateral value will have any assets in it except coin.
+     */
+    set_collateral_return_and_total(collateral_return: TransactionOutput): void;
+    set_current_treasury_value(current_treasury_value: BigNum): void;
+    set_donation(donation: BigNum): void;
+    /**
+     * Set exact fee for the transaction. If the real fee will be bigger then the set value, the transaction will not be created on .build_tx()
+     */
+    set_fee(fee: BigNum): void;
+    set_inputs(inputs: TxInputsBuilder): void;
+    /**
+     * Set metadata using a GeneralTransactionMetadata object
+     * It will be set to the existing or new auxiliary data in this builder
+     */
+    set_metadata(metadata: GeneralTransactionMetadata): void;
+    /**
+     * Set minimal fee for the transaction. If the real fee will be bigger then the set value, the transaction will be created with the real fee.
+     */
+    set_min_fee(fee: BigNum): void;
+    /**
+     * !!! DEPRECATED !!!
+     * Mints are defining by MintBuilder now.
+     * Use `.set_mint_builder()` and `MintBuilder` instead.
+     * Set explicit Mint object and the required witnesses to this builder
+     * it will replace any previously existing mint and mint scripts
+     * NOTE! Error will be returned in case a mint policy does not have a matching script
+     */
+    set_mint(mint: Mint, mint_scripts: NativeScripts): void;
+    /**
+     * !!! DEPRECATED !!!
+     * Mints are defining by MintBuilder now.
+     * Use `.set_mint_builder()` and `MintBuilder` instead.
+     * Add a mint entry to this builder using a PolicyID and MintAssets object
+     * It will be securely added to existing or new Mint in this builder
+     * It will replace any existing mint assets with the same PolicyID
+     */
+    set_mint_asset(policy_script: NativeScript, mint_assets: MintAssets): void;
+    set_mint_builder(mint_builder: MintBuilder): void;
+    /**
+     * Sets the specified hash value.
+     * Alternatively you can use `.calc_script_data_hash` to calculate the hash automatically.
+     * Or use `.remove_script_data_hash` to delete the previously set value
+     */
+    set_script_data_hash(hash: ScriptDataHash): void;
+    set_total_collateral(total_collateral: BigNum): void;
+    /**
+     * This function will set the total-collateral coin and then auto-calculate and assign
+     * the collateral return value. Will raise an error in case no collateral inputs are set.
+     * The specified address will be the received of the collateral return
+     */
+    set_total_collateral_and_return(total_collateral: BigNum, return_address: Address): void;
+    /**
+     * !!! DEPRECATED !!!
+     * Set ttl value.
+     */
+    set_ttl(ttl: number): void;
+    set_ttl_bignum(ttl: BigNum): void;
+    /**
+     * !!! DEPRECATED !!!
+     * Uses outdated slot number format.
+     */
+    set_validity_start_interval(validity_start_interval: number): void;
+    set_validity_start_interval_bignum(validity_start_interval: BigNum): void;
+    set_voting_builder(voting_builder: VotingBuilder): void;
+    set_voting_proposal_builder(voting_proposal_builder: VotingProposalBuilder): void;
+    /**
+     * !!! DEPRECATED !!!
+     * Can emit error if add a withdrawal with script credential.
+     * Use set_withdrawals_builder instead.
+     */
+    set_withdrawals(withdrawals: Withdrawals): void;
+    set_withdrawals_builder(withdrawals: WithdrawalsBuilder): void;
+}
+
+export class TransactionBuilderConfig {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+}
+
+export class TransactionBuilderConfigBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    build(): TransactionBuilderConfig;
+    coins_per_utxo_byte(coins_per_utxo_byte: BigNum): TransactionBuilderConfigBuilder;
+    /**
+     * Removes a ref input (that was set via set_reference_inputs) if the ref inputs was presented in regular tx inputs
+     */
+    deduplicate_explicit_ref_inputs_with_regular_inputs(deduplicate_explicit_ref_inputs_with_regular_inputs: boolean): TransactionBuilderConfigBuilder;
+    /**
+     * If set to true, the transaction builder will not burn extra change if it's impossible to crate change output
+     * due to the value being too small to cover min ada for change output. Instead, tx builder will throw an error.
+     */
+    do_not_burn_extra_change(do_not_burn_extra_change: boolean): TransactionBuilderConfigBuilder;
+    ex_unit_prices(ex_unit_prices: ExUnitPrices): TransactionBuilderConfigBuilder;
+    fee_algo(fee_algo: LinearFee): TransactionBuilderConfigBuilder;
+    key_deposit(key_deposit: BigNum): TransactionBuilderConfigBuilder;
+    max_tx_size(max_tx_size: number): TransactionBuilderConfigBuilder;
+    max_value_size(max_value_size: number): TransactionBuilderConfigBuilder;
+    static new(): TransactionBuilderConfigBuilder;
+    pool_deposit(pool_deposit: BigNum): TransactionBuilderConfigBuilder;
+    prefer_pure_change(prefer_pure_change: boolean): TransactionBuilderConfigBuilder;
+    ref_script_coins_per_byte(ref_script_coins_per_byte: UnitInterval): TransactionBuilderConfigBuilder;
+}
+
+export class TransactionHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): TransactionHash;
+    static from_bytes(bytes: Uint8Array): TransactionHash;
+    static from_hex(hex: string): TransactionHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class TransactionInput {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): TransactionInput;
+    static from_hex(hex_str: string): TransactionInput;
+    static from_json(json: string): TransactionInput;
+    index(): number;
+    static new(transaction_id: TransactionHash, index: number): TransactionInput;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    transaction_id(): TransactionHash;
+}
+
+export class TransactionInputs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a new `TransactionInput` to the set.
+     * Returns `true` if the element was not already present in the set.
+     */
+    add(input: TransactionInput): boolean;
+    static from_bytes(bytes: Uint8Array): TransactionInputs;
+    static from_hex(hex_str: string): TransactionInputs;
+    static from_json(json: string): TransactionInputs;
+    get(index: number): TransactionInput;
+    len(): number;
+    static new(): TransactionInputs;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    to_option(): TransactionInputs | undefined;
+}
+
+export class TransactionMetadatum {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    as_bytes(): Uint8Array;
+    as_int(): Int;
+    as_list(): MetadataList;
+    as_map(): MetadataMap;
+    as_text(): string;
+    static from_bytes(bytes: Uint8Array): TransactionMetadatum;
+    static from_hex(hex_str: string): TransactionMetadatum;
+    kind(): TransactionMetadatumKind;
+    static new_bytes(bytes: Uint8Array): TransactionMetadatum;
+    static new_int(int: Int): TransactionMetadatum;
+    static new_list(list: MetadataList): TransactionMetadatum;
+    static new_map(map: MetadataMap): TransactionMetadatum;
+    static new_text(text: string): TransactionMetadatum;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export enum TransactionMetadatumKind {
+    MetadataMap = 0,
+    MetadataList = 1,
+    Int = 2,
+    Bytes = 3,
+    Text = 4,
+}
+
+export class TransactionMetadatumLabels {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: BigNum): void;
+    static from_bytes(bytes: Uint8Array): TransactionMetadatumLabels;
+    static from_hex(hex_str: string): TransactionMetadatumLabels;
+    get(index: number): BigNum;
+    len(): number;
+    static new(): TransactionMetadatumLabels;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class TransactionOutput {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    address(): Address;
+    amount(): Value;
+    data_hash(): DataHash | undefined;
+    static from_bytes(bytes: Uint8Array): TransactionOutput;
+    static from_hex(hex_str: string): TransactionOutput;
+    static from_json(json: string): TransactionOutput;
+    has_data_hash(): boolean;
+    has_plutus_data(): boolean;
+    has_script_ref(): boolean;
+    static new(address: Address, amount: Value): TransactionOutput;
+    plutus_data(): PlutusData | undefined;
+    script_ref(): ScriptRef | undefined;
+    serialization_format(): CborContainerType | undefined;
+    set_data_hash(data_hash: DataHash): void;
+    set_plutus_data(data: PlutusData): void;
+    set_script_ref(script_ref: ScriptRef): void;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class TransactionOutputAmountBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    build(): TransactionOutput;
+    with_asset_and_min_required_coin_by_utxo_cost(multiasset: MultiAsset, data_cost: DataCost): TransactionOutputAmountBuilder;
+    with_coin(coin: BigNum): TransactionOutputAmountBuilder;
+    with_coin_and_asset(coin: BigNum, multiasset: MultiAsset): TransactionOutputAmountBuilder;
+    with_value(amount: Value): TransactionOutputAmountBuilder;
+}
+
+/**
+ * We introduce a builder-pattern format for creating transaction outputs
+ * This is because:
+ * 1. Some fields (i.e. data hash) are optional, and we can't easily expose Option<> in WASM
+ * 2. Some fields like amounts have many ways it could be set (some depending on other field values being known)
+ * 3. Easier to adapt as the output format gets more complicated in future Cardano releases
+ */
+export class TransactionOutputBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static new(): TransactionOutputBuilder;
+    next(): TransactionOutputAmountBuilder;
+    with_address(address: Address): TransactionOutputBuilder;
+    with_data_hash(data_hash: DataHash): TransactionOutputBuilder;
+    with_plutus_data(data: PlutusData): TransactionOutputBuilder;
+    with_script_ref(script_ref: ScriptRef): TransactionOutputBuilder;
+}
+
+export class TransactionOutputs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: TransactionOutput): void;
+    static from_bytes(bytes: Uint8Array): TransactionOutputs;
+    static from_hex(hex_str: string): TransactionOutputs;
+    static from_json(json: string): TransactionOutputs;
+    get(index: number): TransactionOutput;
+    len(): number;
+    static new(): TransactionOutputs;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export enum TransactionSetsState {
+    AllSetsHaveTag = 0,
+    AllSetsHaveNoTag = 1,
+    MixedSets = 2,
+}
+
+export class TransactionUnspentOutput {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): TransactionUnspentOutput;
+    static from_hex(hex_str: string): TransactionUnspentOutput;
+    static from_json(json: string): TransactionUnspentOutput;
+    input(): TransactionInput;
+    static new(input: TransactionInput, output: TransactionOutput): TransactionUnspentOutput;
+    output(): TransactionOutput;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class TransactionUnspentOutputs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: TransactionUnspentOutput): void;
+    static from_json(json: string): TransactionUnspentOutputs;
+    get(index: number): TransactionUnspentOutput;
+    len(): number;
+    static new(): TransactionUnspentOutputs;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class TransactionWitnessSet {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    bootstraps(): BootstrapWitnesses | undefined;
+    static from_bytes(bytes: Uint8Array): TransactionWitnessSet;
+    static from_hex(hex_str: string): TransactionWitnessSet;
+    static from_json(json: string): TransactionWitnessSet;
+    native_scripts(): NativeScripts | undefined;
+    static new(): TransactionWitnessSet;
+    plutus_data(): PlutusList | undefined;
+    plutus_scripts(): PlutusScripts | undefined;
+    redeemers(): Redeemers | undefined;
+    set_bootstraps(bootstraps: BootstrapWitnesses): void;
+    set_native_scripts(native_scripts: NativeScripts): void;
+    set_plutus_data(plutus_data: PlutusList): void;
+    set_plutus_scripts(plutus_scripts: PlutusScripts): void;
+    set_redeemers(redeemers: Redeemers): void;
+    set_vkeys(vkeys: Vkeywitnesses): void;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    vkeys(): Vkeywitnesses | undefined;
+}
+
+export class TransactionWitnessSets {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: TransactionWitnessSet): void;
+    static from_bytes(bytes: Uint8Array): TransactionWitnessSets;
+    static from_hex(hex_str: string): TransactionWitnessSets;
+    static from_json(json: string): TransactionWitnessSets;
+    get(index: number): TransactionWitnessSet;
+    len(): number;
+    static new(): TransactionWitnessSets;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class TreasuryWithdrawals {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_json(json: string): TreasuryWithdrawals;
+    get(key: RewardAddress): BigNum | undefined;
+    insert(key: RewardAddress, value: BigNum): void;
+    keys(): RewardAddresses;
+    len(): number;
+    static new(): TreasuryWithdrawals;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class TreasuryWithdrawalsAction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): TreasuryWithdrawalsAction;
+    static from_hex(hex_str: string): TreasuryWithdrawalsAction;
+    static from_json(json: string): TreasuryWithdrawalsAction;
+    static new(withdrawals: TreasuryWithdrawals): TreasuryWithdrawalsAction;
+    static new_with_policy_hash(withdrawals: TreasuryWithdrawals, policy_hash: ScriptHash): TreasuryWithdrawalsAction;
+    policy_hash(): ScriptHash | undefined;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    withdrawals(): TreasuryWithdrawals;
+}
+
+export class TxInputsBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add_bootstrap_input(address: ByronAddress, input: TransactionInput, amount: Value): void;
+    /**
+     * We have to know what kind of inputs these are to know what kind of mock witnesses to create since
+     * 1) mock witnesses have different lengths depending on the type which changes the expecting fee
+     * 2) Witnesses are a set so we need to get rid of duplicates to avoid over-estimating the fee
+     */
+    add_key_input(hash: Ed25519KeyHash, input: TransactionInput, amount: Value): void;
+    /**
+     * This method will add the input to the builder and also register the required native script witness
+     */
+    add_native_script_input(script: NativeScriptSource, input: TransactionInput, amount: Value): void;
+    add_native_script_utxo(utxo: TransactionUnspentOutput, witness: NativeScriptSource): void;
+    /**
+     * This method will add the input to the builder and also register the required plutus witness
+     */
+    add_plutus_script_input(witness: PlutusWitness, input: TransactionInput, amount: Value): void;
+    add_plutus_script_utxo(utxo: TransactionUnspentOutput, witness: PlutusWitness): void;
+    /**
+     * Adds non script input, in case of script or reward address input it will return an error
+     */
+    add_regular_input(address: Address, input: TransactionInput, amount: Value): void;
+    add_regular_utxo(utxo: TransactionUnspentOutput): void;
+    add_required_signer(key: Ed25519KeyHash): void;
+    add_required_signers(keys: Ed25519KeyHashes): void;
+    /**
+     * Returns a copy of the current script input witness scripts in the builder
+     */
+    get_native_input_scripts(): NativeScripts | undefined;
+    /**
+     * Returns a copy of the current plutus input witness scripts in the builder.
+     * NOTE: each plutus witness will be cloned with a specific corresponding input index
+     */
+    get_plutus_input_scripts(): PlutusWitnesses | undefined;
+    get_ref_inputs(): TransactionInputs;
+    inputs(): TransactionInputs;
+    inputs_option(): TransactionInputs | undefined;
+    len(): number;
+    static new(): TxInputsBuilder;
+    total_value(): Value;
+}
+
+export class URL {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): URL;
+    static from_hex(hex_str: string): URL;
+    static from_json(json: string): URL;
+    static new(url: string): URL;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    url(): string;
+}
+
+export class UnitInterval {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    denominator(): BigNum;
+    static from_bytes(bytes: Uint8Array): UnitInterval;
+    static from_hex(hex_str: string): UnitInterval;
+    static from_json(json: string): UnitInterval;
+    static new(numerator: BigNum, denominator: BigNum): UnitInterval;
+    numerator(): BigNum;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Update {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    epoch(): number;
+    static from_bytes(bytes: Uint8Array): Update;
+    static from_hex(hex_str: string): Update;
+    static from_json(json: string): Update;
+    static new(proposed_protocol_parameter_updates: ProposedProtocolParameterUpdates, epoch: number): Update;
+    proposed_protocol_parameter_updates(): ProposedProtocolParameterUpdates;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class UpdateCommitteeAction {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    committee(): Committee;
+    static from_bytes(bytes: Uint8Array): UpdateCommitteeAction;
+    static from_hex(hex_str: string): UpdateCommitteeAction;
+    static from_json(json: string): UpdateCommitteeAction;
+    gov_action_id(): GovernanceActionId | undefined;
+    members_to_remove(): Credentials;
+    static new(committee: Committee, members_to_remove: Credentials): UpdateCommitteeAction;
+    static new_with_action_id(gov_action_id: GovernanceActionId, committee: Committee, members_to_remove: Credentials): UpdateCommitteeAction;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class VRFCert {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): VRFCert;
+    static from_hex(hex_str: string): VRFCert;
+    static from_json(json: string): VRFCert;
+    static new(output: Uint8Array, proof: Uint8Array): VRFCert;
+    output(): Uint8Array;
+    proof(): Uint8Array;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class VRFKeyHash {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): VRFKeyHash;
+    static from_bytes(bytes: Uint8Array): VRFKeyHash;
+    static from_hex(hex: string): VRFKeyHash;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class VRFVKey {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bech32(bech_str: string): VRFVKey;
+    static from_bytes(bytes: Uint8Array): VRFVKey;
+    static from_hex(hex: string): VRFVKey;
+    to_bech32(prefix: string): string;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+}
+
+export class Value {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    checked_add(rhs: Value): Value;
+    checked_sub(rhs_value: Value): Value;
+    clamped_sub(rhs_value: Value): Value;
+    coin(): BigNum;
+    /**
+     * note: values are only partially comparable
+     */
+    compare(rhs_value: Value): number | undefined;
+    static from_bytes(bytes: Uint8Array): Value;
+    static from_hex(hex_str: string): Value;
+    static from_json(json: string): Value;
+    is_zero(): boolean;
+    multiasset(): MultiAsset | undefined;
+    static new(coin: BigNum): Value;
+    static new_from_assets(multiasset: MultiAsset): Value;
+    static new_with_assets(coin: BigNum, multiasset: MultiAsset): Value;
+    set_coin(coin: BigNum): void;
+    set_multiasset(multiasset: MultiAsset): void;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    static zero(): Value;
+}
+
+export class VersionedBlock {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    block(): Block;
+    era(): BlockEra;
+    static from_bytes(bytes: Uint8Array): VersionedBlock;
+    static from_hex(hex_str: string): VersionedBlock;
+    static from_json(json: string): VersionedBlock;
+    static new(block: Block, era_code: number): VersionedBlock;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Vkey {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): Vkey;
+    static from_hex(hex_str: string): Vkey;
+    static from_json(json: string): Vkey;
+    static new(pk: PublicKey): Vkey;
+    public_key(): PublicKey;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Vkeys {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(elem: Vkey): void;
+    get(index: number): Vkey;
+    len(): number;
+    static new(): Vkeys;
+}
+
+export class Vkeywitness {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): Vkeywitness;
+    static from_hex(hex_str: string): Vkeywitness;
+    static from_json(json: string): Vkeywitness;
+    static new(vkey: Vkey, signature: Ed25519Signature): Vkeywitness;
+    signature(): Ed25519Signature;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    vkey(): Vkey;
+}
+
+export class Vkeywitnesses {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a new `Vkeywitness` to the set.
+     * Returns `true` if the element was not already present in the set.
+     */
+    add(witness: Vkeywitness): boolean;
+    static from_bytes(bytes: Uint8Array): Vkeywitnesses;
+    static from_hex(hex_str: string): Vkeywitnesses;
+    static from_json(json: string): Vkeywitnesses;
+    get(index: number): Vkeywitness;
+    len(): number;
+    static new(): Vkeywitnesses;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class VoteDelegation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    drep(): DRep;
+    static from_bytes(bytes: Uint8Array): VoteDelegation;
+    static from_hex(hex_str: string): VoteDelegation;
+    static from_json(json: string): VoteDelegation;
+    has_script_credentials(): boolean;
+    static new(stake_credential: Credential, drep: DRep): VoteDelegation;
+    stake_credential(): Credential;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export enum VoteKind {
+    No = 0,
+    Yes = 1,
+    Abstain = 2,
+}
+
+export class VoteRegistrationAndDelegation {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    coin(): BigNum;
+    drep(): DRep;
+    static from_bytes(bytes: Uint8Array): VoteRegistrationAndDelegation;
+    static from_hex(hex_str: string): VoteRegistrationAndDelegation;
+    static from_json(json: string): VoteRegistrationAndDelegation;
+    has_script_credentials(): boolean;
+    static new(stake_credential: Credential, drep: DRep, coin: BigNum): VoteRegistrationAndDelegation;
+    stake_credential(): Credential;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class Voter {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): Voter;
+    static from_hex(hex_str: string): Voter;
+    static from_json(json: string): Voter;
+    has_script_credentials(): boolean;
+    kind(): VoterKind;
+    static new_constitutional_committee_hot_credential(cred: Credential): Voter;
+    static new_drep_credential(cred: Credential): Voter;
+    static new_stake_pool_key_hash(key_hash: Ed25519KeyHash): Voter;
+    to_bytes(): Uint8Array;
+    to_constitutional_committee_hot_credential(): Credential | undefined;
+    to_drep_credential(): Credential | undefined;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    to_key_hash(): Ed25519KeyHash | undefined;
+    to_stake_pool_key_hash(): Ed25519KeyHash | undefined;
+}
+
+export enum VoterKind {
+    ConstitutionalCommitteeHotKeyHash = 0,
+    ConstitutionalCommitteeHotScriptHash = 1,
+    DRepKeyHash = 2,
+    DRepScriptHash = 3,
+    StakingPoolKeyHash = 4,
+}
+
+export class Voters {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(voter: Voter): void;
+    static from_json(json: string): Voters;
+    get(index: number): Voter | undefined;
+    len(): number;
+    static new(): Voters;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class VotingBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(voter: Voter, gov_action_id: GovernanceActionId, voting_procedure: VotingProcedure): void;
+    add_with_native_script(voter: Voter, gov_action_id: GovernanceActionId, voting_procedure: VotingProcedure, native_script_source: NativeScriptSource): void;
+    add_with_plutus_witness(voter: Voter, gov_action_id: GovernanceActionId, voting_procedure: VotingProcedure, witness: PlutusWitness): void;
+    build(): VotingProcedures;
+    get_native_scripts(): NativeScripts;
+    get_plutus_witnesses(): PlutusWitnesses;
+    get_ref_inputs(): TransactionInputs;
+    has_plutus_scripts(): boolean;
+    static new(): VotingBuilder;
+}
+
+export class VotingProcedure {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    anchor(): Anchor | undefined;
+    static from_bytes(bytes: Uint8Array): VotingProcedure;
+    static from_hex(hex_str: string): VotingProcedure;
+    static from_json(json: string): VotingProcedure;
+    static new(vote: VoteKind): VotingProcedure;
+    static new_with_anchor(vote: VoteKind, anchor: Anchor): VotingProcedure;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    vote_kind(): VoteKind;
+}
+
+export class VotingProcedures {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): VotingProcedures;
+    static from_hex(hex_str: string): VotingProcedures;
+    static from_json(json: string): VotingProcedures;
+    get(voter: Voter, governance_action_id: GovernanceActionId): VotingProcedure | undefined;
+    get_governance_action_ids_by_voter(voter: Voter): GovernanceActionIds;
+    get_voters(): Voters;
+    insert(voter: Voter, governance_action_id: GovernanceActionId, voting_procedure: VotingProcedure): void;
+    static new(): VotingProcedures;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class VotingProposal {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    anchor(): Anchor;
+    deposit(): BigNum;
+    static from_bytes(bytes: Uint8Array): VotingProposal;
+    static from_hex(hex_str: string): VotingProposal;
+    static from_json(json: string): VotingProposal;
+    governance_action(): GovernanceAction;
+    static new(governance_action: GovernanceAction, anchor: Anchor, reward_account: RewardAddress, deposit: BigNum): VotingProposal;
+    reward_account(): RewardAddress;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class VotingProposalBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(proposal: VotingProposal): void;
+    add_with_plutus_witness(proposal: VotingProposal, witness: PlutusWitness): void;
+    build(): VotingProposals;
+    get_plutus_witnesses(): PlutusWitnesses;
+    get_ref_inputs(): TransactionInputs;
+    has_plutus_scripts(): boolean;
+    static new(): VotingProposalBuilder;
+}
+
+export class VotingProposals {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Add a new `VotingProposal` to the set.
+     * Returns `true` if the element was not already present in the set.
+     */
+    add(proposal: VotingProposal): boolean;
+    contains(elem: VotingProposal): boolean;
+    static from_bytes(bytes: Uint8Array): VotingProposals;
+    static from_hex(hex_str: string): VotingProposals;
+    static from_json(json: string): VotingProposals;
+    get(index: number): VotingProposal;
+    len(): number;
+    static new(): VotingProposals;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+    to_option(): VotingProposals | undefined;
+}
+
+export class Withdrawals {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    static from_bytes(bytes: Uint8Array): Withdrawals;
+    static from_hex(hex_str: string): Withdrawals;
+    static from_json(json: string): Withdrawals;
+    get(key: RewardAddress): BigNum | undefined;
+    insert(key: RewardAddress, value: BigNum): BigNum | undefined;
+    keys(): RewardAddresses;
+    len(): number;
+    static new(): Withdrawals;
+    to_bytes(): Uint8Array;
+    to_hex(): string;
+    to_js_value(): any;
+    to_json(): string;
+}
+
+export class WithdrawalsBuilder {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    add(address: RewardAddress, coin: BigNum): void;
+    add_with_native_script(address: RewardAddress, coin: BigNum, native_script_source: NativeScriptSource): void;
+    add_with_plutus_witness(address: RewardAddress, coin: BigNum, witness: PlutusWitness): void;
+    build(): Withdrawals;
+    get_native_scripts(): NativeScripts;
+    get_plutus_witnesses(): PlutusWitnesses;
+    get_ref_inputs(): TransactionInputs;
+    get_total_withdrawals(): Value;
+    has_plutus_scripts(): boolean;
+    static new(): WithdrawalsBuilder;
+}
+
+export function buildAndSign(request_json: string): Uint8Array;
+
+export function buildAndSignFromPrivateKey(request_json: string): Uint8Array;
+
+export function calculate_ex_units_ceil_cost(ex_units: ExUnits, ex_unit_prices: ExUnitPrices): BigNum;
+
+export function create_send_all(address: Address, utxos: TransactionUnspentOutputs, config: TransactionBuilderConfig): TransactionBatchList;
+
+export function decode_arbitrary_bytes_from_metadatum(metadata: TransactionMetadatum): Uint8Array;
+
+export function decode_metadatum_to_json_str(metadatum: TransactionMetadatum, schema: MetadataJsonSchema): string;
+
+export function decode_plutus_datum_to_json_str(datum: PlutusData, schema: PlutusDatumSchema): string;
+
+export function decrypt_with_password(password: string, data: string): string;
+
+export function deriveAddress(request_json: string): string;
+
+export function deriveAddressFromPrivateKey(request_json: string): string;
+
+export function deriveWallet(request_json: string): string;
+
+export function deriveWalletFromPrivateKey(request_json: string): string;
+
+export function encode_arbitrary_bytes_as_metadatum(bytes: Uint8Array): TransactionMetadatum;
+
+export function encode_json_str_to_metadatum(json: string, schema: MetadataJsonSchema): TransactionMetadatum;
+
+/**
+ * Receives a script JSON string
+ * and returns a NativeScript.
+ * Cardano Wallet and Node styles are supported.
+ *
+ * * wallet: https://github.com/input-output-hk/cardano-wallet/blob/master/specifications/api/swagger.yaml
+ * * node: https://github.com/input-output-hk/cardano-node/blob/master/doc/reference/simple-scripts.md
+ *
+ * self_xpub is expected to be a Bip32PublicKey as hex-encoded bytes
+ */
+export function encode_json_str_to_native_script(json: string, self_xpub: string, schema: ScriptSchema): NativeScript;
+
+export function encode_json_str_to_plutus_datum(json: string, schema: PlutusDatumSchema): PlutusData;
+
+export function encrypt_with_password(password: string, salt: string, nonce: string, data: string): string;
+
+export function get_deposit(txbody: TransactionBody, pool_deposit: BigNum, key_deposit: BigNum): BigNum;
+
+export function get_implicit_input(txbody: TransactionBody, pool_deposit: BigNum, key_deposit: BigNum): Value;
+
+/**
+ * Returns the state of the transaction sets.
+ * If all sets have a tag, it returns AllSetsHaveTag.
+ * If all sets have no tag, it returns AllSetsHaveNoTag.
+ * If there is a mix of tagged and untagged sets, it returns MixedSets.
+ * This function is useful for checking if a transaction might be signed by a hardware wallet.
+ * And for checking which parameter should be used in a hardware wallet api.
+ * WARNING this function will be deleted after all tags for set types will be mandatory. Approx after next hf
+ */
+export function has_transaction_set_tag(tx_bytes: Uint8Array): TransactionSetsState;
+
+export function hash_auxiliary_data(auxiliary_data: AuxiliaryData): AuxiliaryDataHash;
+
+export function hash_plutus_data(plutus_data: PlutusData): DataHash;
+
+export function hash_script_data(redeemers: Redeemers, cost_models: Costmdls, datums?: PlutusList | null): ScriptDataHash;
+
+export function init(): void;
+
+export function invokeChainExtension(chain_id: string, method: string, payload_json: string): string;
+
+export function listChainExtensions(): string;
+
+export function listSupportedChains(): string;
+
+export function make_daedalus_bootstrap_witness(tx_body_hash: TransactionHash, addr: ByronAddress, key: LegacyDaedalusPrivateKey): BootstrapWitness;
+
+export function make_icarus_bootstrap_witness(tx_body_hash: TransactionHash, addr: ByronAddress, key: Bip32PrivateKey): BootstrapWitness;
+
+export function make_vkey_witness(tx_body_hash: TransactionHash, sk: PrivateKey): Vkeywitness;
+
+/**
+ * returns minimal amount of ada for the output for case when the amount is included to the output
+ */
+export function min_ada_for_output(output: TransactionOutput, data_cost: DataCost): BigNum;
+
+export function min_fee(tx: Transaction, linear_fee: LinearFee): BigNum;
+
+export function min_ref_script_fee(total_ref_scripts_size: number, ref_script_coins_per_byte: UnitInterval): BigNum;
+
+export function min_script_fee(tx: Transaction, ex_unit_prices: ExUnitPrices): BigNum;
+
+export function signBytes(request_json: string): Uint8Array;
+
+export function signBytesFromPrivateKey(request_json: string): Uint8Array;
+
+export function signMessage(request_json: string): Uint8Array;
+
+export function signMessageFromPrivateKey(request_json: string): Uint8Array;
+
+export function signTypedData(request_json: string): Uint8Array;
+
+export function signTypedDataFromPrivateKey(request_json: string): Uint8Array;