Variable bcsConst

bcs: {
    Address: BcsType<string, string | Uint8Array<ArrayBufferLike>>;
    AppId: BcsType<
        { $kind: "Sui"; Sui: true },
        { Sui: null | boolean | object },
    >;
    Argument: BcsType<
        EnumOutputShapeWithKeys<
            {
                GasCoin: true;
                Input: number;
                NestedResult: [number, number];
                Result: number;
            },
            "GasCoin"
            | "Input"
            | "Result"
            | "NestedResult",
        >,
        EnumInputShape<
            {
                GasCoin: null
                | boolean
                | object;
                Input: number;
                NestedResult: readonly [number, number];
                Result: number;
            },
        >,
    >;
    Bool: BcsType<boolean, boolean>;
    CallArg: BcsType<
        EnumOutputShapeWithKeys<
            {
                Object: EnumOutputShapeWithKeys<
                    {
                        ImmOrOwnedObject: {
                            digest: string;
                            objectId: string;
                            version: string;
                        };
                        Receiving: { digest: string; objectId: string; version: string };
                        SharedObject: {
                            initialSharedVersion: string;
                            mutable: boolean;
                            objectId: string;
                        };
                    },
                    "ImmOrOwnedObject"
                    | "SharedObject"
                    | "Receiving",
                >;
                Pure: { bytes: string };
            },
            "Pure"
            | "Object",
        >,
        EnumInputShape<
            {
                Object: EnumInputShape<
                    {
                        ImmOrOwnedObject: {
                            digest: string;
                            objectId: string
                            | Uint8Array<ArrayBufferLike>;
                            version: string | number | bigint;
                        };
                        Receiving: {
                            digest: string;
                            objectId: string
                            | Uint8Array<ArrayBufferLike>;
                            version: string | number | bigint;
                        };
                        SharedObject: {
                            initialSharedVersion: string
                            | number
                            | bigint;
                            mutable: boolean;
                            objectId: string | Uint8Array<ArrayBufferLike>;
                        };
                    },
                >;
                Pure: { bytes: string
                | Uint8Array<ArrayBufferLike> };
            },
        >,
    >;
    Command: BcsType<
        EnumOutputShapeWithKeys<
            {
                MakeMoveVec: {
                    elements: EnumOutputShapeWithKeys<
                        {
                            GasCoin: true;
                            Input: number;
                            NestedResult: [number, number];
                            Result: number;
                        },
                        "GasCoin"
                        | "Input"
                        | "Result"
                        | "NestedResult",
                    >[];
                    type: null | string;
                };
                MergeCoins: {
                    destination: EnumOutputShapeWithKeys<
                        {
                            GasCoin: true;
                            Input: number;
                            NestedResult: [number, number];
                            Result: number;
                        },
                        "GasCoin"
                        | "Input"
                        | "Result"
                        | "NestedResult",
                    >;
                    sources: EnumOutputShapeWithKeys<
                        {
                            GasCoin: true;
                            Input: number;
                            NestedResult: [number, number];
                            Result: number;
                        },
                        "GasCoin"
                        | "Input"
                        | "Result"
                        | "NestedResult",
                    >[];
                };
                MoveCall: {
                    arguments: EnumOutputShapeWithKeys<
                        {
                            GasCoin: true;
                            Input: number;
                            NestedResult: [number, number];
                            Result: number;
                        },
                        "GasCoin"
                        | "Input"
                        | "Result"
                        | "NestedResult",
                    >[];
                    function: string;
                    module: string;
                    package: string;
                    typeArguments: string[];
                };
                Publish: { dependencies: string[]; modules: string[] };
                SplitCoins: {
                    amounts: EnumOutputShapeWithKeys<
                        {
                            GasCoin: true;
                            Input: number;
                            NestedResult: [number, number];
                            Result: number;
                        },
                        "GasCoin"
                        | "Input"
                        | "Result"
                        | "NestedResult",
                    >[];
                    coin: EnumOutputShapeWithKeys<
                        {
                            GasCoin: true;
                            Input: number;
                            NestedResult: [number, number];
                            Result: number;
                        },
                        "GasCoin"
                        | "Input"
                        | "Result"
                        | "NestedResult",
                    >;
                };
                TransferObjects: {
                    address: EnumOutputShapeWithKeys<
                        {
                            GasCoin: true;
                            Input: number;
                            NestedResult: [number, number];
                            Result: number;
                        },
                        "GasCoin"
                        | "Input"
                        | "Result"
                        | "NestedResult",
                    >;
                    objects: EnumOutputShapeWithKeys<
                        {
                            GasCoin: true;
                            Input: number;
                            NestedResult: [number, number];
                            Result: number;
                        },
                        "GasCoin"
                        | "Input"
                        | "Result"
                        | "NestedResult",
                    >[];
                };
                Upgrade: {
                    dependencies: string[];
                    modules: string[];
                    package: string;
                    ticket: EnumOutputShapeWithKeys<
                        {
                            GasCoin: true;
                            Input: number;
                            NestedResult: [number, number];
                            Result: number;
                        },
                        "GasCoin"
                        | "Input"
                        | "Result"
                        | "NestedResult",
                    >;
                };
            },
            | "MoveCall"
            | "TransferObjects"
            | "SplitCoins"
            | "MergeCoins"
            | "Publish"
            | "MakeMoveVec"
            | "Upgrade",
        >,
        EnumInputShape<
            {
                MakeMoveVec: {
                    elements: Iterable<
                        EnumInputShape<
                            {
                                GasCoin: null
                                | boolean
                                | object;
                                Input: number;
                                NestedResult: readonly [number, number];
                                Result: number;
                            },
                        >,
                        any,
                        any,
                    > & { length: number };
                    type: null | string;
                };
                MergeCoins: {
                    destination: EnumInputShape<
                        {
                            GasCoin: null
                            | boolean
                            | object;
                            Input: number;
                            NestedResult: readonly [number, number];
                            Result: number;
                        },
                    >;
                    sources: Iterable<
                        EnumInputShape<
                            {
                                GasCoin: null
                                | boolean
                                | object;
                                Input: number;
                                NestedResult: readonly [number, number];
                                Result: number;
                            },
                        >,
                        any,
                        any,
                    > & { length: number };
                };
                MoveCall: {
                    arguments: Iterable<
                        EnumInputShape<
                            {
                                GasCoin: null
                                | boolean
                                | object;
                                Input: number;
                                NestedResult: readonly [number, number];
                                Result: number;
                            },
                        >,
                        any,
                        any,
                    > & { length: number };
                    function: string;
                    module: string;
                    package: string | Uint8Array<ArrayBufferLike>;
                    typeArguments: Iterable<string | TypeTag, any, any> & {
                        length: number;
                    };
                };
                Publish: {
                    dependencies: Iterable<
                        string
                        | Uint8Array<ArrayBufferLike>,
                        any,
                        any,
                    > & { length: number };
                    modules: Iterable<string | Uint8Array<ArrayBufferLike>, any, any> & {
                        length: number;
                    };
                };
                SplitCoins: {
                    amounts: Iterable<
                        EnumInputShape<
                            {
                                GasCoin: null
                                | boolean
                                | object;
                                Input: number;
                                NestedResult: readonly [number, number];
                                Result: number;
                            },
                        >,
                        any,
                        any,
                    > & { length: number };
                    coin: EnumInputShape<
                        {
                            GasCoin: null
                            | boolean
                            | object;
                            Input: number;
                            NestedResult: readonly [number, number];
                            Result: number;
                        },
                    >;
                };
                TransferObjects: {
                    address: EnumInputShape<
                        {
                            GasCoin: null
                            | boolean
                            | object;
                            Input: number;
                            NestedResult: readonly [number, number];
                            Result: number;
                        },
                    >;
                    objects: Iterable<
                        EnumInputShape<
                            {
                                GasCoin: null
                                | boolean
                                | object;
                                Input: number;
                                NestedResult: readonly [number, number];
                                Result: number;
                            },
                        >,
                        any,
                        any,
                    > & { length: number };
                };
                Upgrade: {
                    dependencies: Iterable<
                        string
                        | Uint8Array<ArrayBufferLike>,
                        any,
                        any,
                    > & { length: number };
                    modules: Iterable<string | Uint8Array<ArrayBufferLike>, any, any> & {
                        length: number;
                    };
                    package: string
                    | Uint8Array<ArrayBufferLike>;
                    ticket: EnumInputShape<
                        {
                            GasCoin: null
                            | boolean
                            | object;
                            Input: number;
                            NestedResult: readonly [number, number];
                            Result: number;
                        },
                    >;
                };
            },
        >,
    >;
    CompressedSignature: BcsType<
        EnumOutputShapeWithKeys<
            {
                ED25519: number[];
                Secp256k1: number[];
                Secp256r1: number[];
                ZkLogin: number[];
            },
            "ED25519"
            | "Secp256k1"
            | "Secp256r1"
            | "ZkLogin",
        >,
        EnumInputShape<
            {
                ED25519: Iterable<number, any, any> & { length: number };
                Secp256k1: Iterable<number, any, any> & { length: number };
                Secp256r1: Iterable<number, any, any> & { length: number };
                ZkLogin: Iterable<number, any, any> & { length: number };
            },
        >,
    >;
    GasData: BcsType<
        {
            budget: string;
            owner: string;
            payment: { digest: string; objectId: string; version: string }[];
            price: string;
        },
        {
            budget: string
            | number
            | bigint;
            owner: string | Uint8Array<ArrayBufferLike>;
            payment: Iterable<
                {
                    digest: string;
                    objectId: string
                    | Uint8Array<ArrayBufferLike>;
                    version: string | number | bigint;
                },
                any,
                any,
            > & { length: number };
            price: string | number | bigint;
        },
    >;
    Intent: BcsType<
        {
            appId: { $kind: "Sui"; Sui: true };
            scope: EnumOutputShapeWithKeys<
                {
                    CheckpointSummary: true;
                    PersonalMessage: true;
                    TransactionData: true;
                    TransactionEffects: true;
                },
                | "TransactionData"
                | "TransactionEffects"
                | "CheckpointSummary"
                | "PersonalMessage",
            >;
            version: { $kind: "V0"; V0: true };
        },
        {
            appId: { Sui: null
            | boolean
            | object };
            scope: EnumInputShape<
                {
                    CheckpointSummary: null
                    | boolean
                    | object;
                    PersonalMessage: null | boolean | object;
                    TransactionData: null | boolean | object;
                    TransactionEffects: null | boolean | object;
                },
            >;
            version: { V0: null
            | boolean
            | object };
        },
    >;
    IntentMessage: <T extends BcsType<any, any>>(
        T: T,
    ) => BcsType<
        {
            intent: {
                appId: { $kind: "Sui"; Sui: true };
                scope: EnumOutputShapeWithKeys<
                    {
                        CheckpointSummary: true;
                        PersonalMessage: true;
                        TransactionData: true;
                        TransactionEffects: true;
                    },
                    | "TransactionData"
                    | "TransactionEffects"
                    | "CheckpointSummary"
                    | "PersonalMessage",
                >;
                version: { $kind: "V0"; V0: true };
            };
            value: T extends BcsType<U, any> ? U : never;
        },
        {
            intent: {
                appId: { Sui: null
                | boolean
                | object };
                scope: EnumInputShape<
                    {
                        CheckpointSummary: null
                        | boolean
                        | object;
                        PersonalMessage: null | boolean | object;
                        TransactionData: null | boolean | object;
                        TransactionEffects: null | boolean | object;
                    },
                >;
                version: { V0: null
                | boolean
                | object };
            };
            value: T extends BcsType<any, U_1> ? U_1 : never;
        },
    >;
    IntentScope: BcsType<
        EnumOutputShapeWithKeys<
            {
                CheckpointSummary: true;
                PersonalMessage: true;
                TransactionData: true;
                TransactionEffects: true;
            },
            | "TransactionData"
            | "TransactionEffects"
            | "CheckpointSummary"
            | "PersonalMessage",
        >,
        EnumInputShape<
            {
                CheckpointSummary: null
                | boolean
                | object;
                PersonalMessage: null | boolean | object;
                TransactionData: null | boolean | object;
                TransactionEffects: null | boolean | object;
            },
        >,
    >;
    IntentVersion: BcsType<
        { $kind: "V0"; V0: true },
        { V0: null | boolean | object },
    >;
    MultiSig: BcsType<
        {
            bitmap: number;
            multisig_pk: {
                pk_map: {
                    pubKey: EnumOutputShapeWithKeys<
                        {
                            ED25519: number[];
                            Secp256k1: number[];
                            Secp256r1: number[];
                            ZkLogin: number[];
                        },
                        "ED25519"
                        | "Secp256k1"
                        | "Secp256r1"
                        | "ZkLogin",
                    >;
                    weight: number;
                }[];
                threshold: number;
            };
            sigs: EnumOutputShapeWithKeys<
                {
                    ED25519: number[];
                    Secp256k1: number[];
                    Secp256r1: number[];
                    ZkLogin: number[];
                },
                "ED25519"
                | "Secp256k1"
                | "Secp256r1"
                | "ZkLogin",
            >[];
        },
        {
            bitmap: number;
            multisig_pk: {
                pk_map: Iterable<
                    {
                        pubKey: EnumInputShape<
                            {
                                ED25519: Iterable<(...), (...), (...)> & { length: ... };
                                Secp256k1: Iterable<(...), (...), (...)> & { length: ... };
                                Secp256r1: Iterable<(...), (...), (...)> & { length: ... };
                                ZkLogin: Iterable<(...), (...), (...)> & { length: ... };
                            },
                        >;
                        weight: number;
                    },
                    any,
                    any,
                > & { length: number };
                threshold: number;
            };
            sigs: Iterable<
                EnumInputShape<
                    {
                        ED25519: Iterable<number, any, any> & { length: number };
                        Secp256k1: Iterable<number, any, any> & { length: number };
                        Secp256r1: Iterable<number, any, any> & { length: number };
                        ZkLogin: Iterable<number, any, any> & { length: number };
                    },
                >,
                any,
                any,
            > & { length: number };
        },
    >;
    MultiSigPkMap: BcsType<
        {
            pubKey: EnumOutputShapeWithKeys<
                {
                    ED25519: number[];
                    Secp256k1: number[];
                    Secp256r1: number[];
                    ZkLogin: number[];
                },
                "ED25519"
                | "Secp256k1"
                | "Secp256r1"
                | "ZkLogin",
            >;
            weight: number;
        },
        {
            pubKey: EnumInputShape<
                {
                    ED25519: Iterable<number, any, any> & { length: number };
                    Secp256k1: Iterable<number, any, any> & { length: number };
                    Secp256r1: Iterable<number, any, any> & { length: number };
                    ZkLogin: Iterable<number, any, any> & { length: number };
                },
            >;
            weight: number;
        },
    >;
    MultiSigPublicKey: BcsType<
        {
            pk_map: {
                pubKey: EnumOutputShapeWithKeys<
                    {
                        ED25519: number[];
                        Secp256k1: number[];
                        Secp256r1: number[];
                        ZkLogin: number[];
                    },
                    "ED25519"
                    | "Secp256k1"
                    | "Secp256r1"
                    | "ZkLogin",
                >;
                weight: number;
            }[];
            threshold: number;
        },
        {
            pk_map: Iterable<
                {
                    pubKey: EnumInputShape<
                        {
                            ED25519: Iterable<number, any, any> & { length: number };
                            Secp256k1: Iterable<number, any, any> & { length: number };
                            Secp256r1: Iterable<number, any, any> & { length: number };
                            ZkLogin: Iterable<number, any, any> & { length: number };
                        },
                    >;
                    weight: number;
                },
                any,
                any,
            > & { length: number };
            threshold: number;
        },
    >;
    ObjectArg: BcsType<
        EnumOutputShapeWithKeys<
            {
                ImmOrOwnedObject: {
                    digest: string;
                    objectId: string;
                    version: string;
                };
                Receiving: { digest: string; objectId: string; version: string };
                SharedObject: {
                    initialSharedVersion: string;
                    mutable: boolean;
                    objectId: string;
                };
            },
            "ImmOrOwnedObject"
            | "SharedObject"
            | "Receiving",
        >,
        EnumInputShape<
            {
                ImmOrOwnedObject: {
                    digest: string;
                    objectId: string
                    | Uint8Array<ArrayBufferLike>;
                    version: string | number | bigint;
                };
                Receiving: {
                    digest: string;
                    objectId: string
                    | Uint8Array<ArrayBufferLike>;
                    version: string | number | bigint;
                };
                SharedObject: {
                    initialSharedVersion: string
                    | number
                    | bigint;
                    mutable: boolean;
                    objectId: string | Uint8Array<ArrayBufferLike>;
                };
            },
        >,
    >;
    ObjectDigest: BcsType<string, string>;
    Owner: BcsType<
        EnumOutputShapeWithKeys<
            {
                AddressOwner: string;
                ConsensusV2: {
                    authenticator: { $kind: "SingleOwner"; SingleOwner: string };
                    startVersion: string;
                };
                Immutable: true;
                ObjectOwner: string;
                Shared: { initialSharedVersion: string };
            },
            "AddressOwner"
            | "ObjectOwner"
            | "Shared"
            | "Immutable"
            | "ConsensusV2",
        >,
        EnumInputShape<
            {
                AddressOwner: string
                | Uint8Array<ArrayBufferLike>;
                ConsensusV2: {
                    authenticator: { SingleOwner: string | Uint8Array<ArrayBufferLike> };
                    startVersion: string | number | bigint;
                };
                Immutable: null
                | boolean
                | object;
                ObjectOwner: string | Uint8Array<ArrayBufferLike>;
                Shared: { initialSharedVersion: string | number | bigint };
            },
        >,
    >;
    PasskeyAuthenticator: BcsType<
        {
            authenticatorData: number[];
            clientDataJson: string;
            userSignature: number[];
        },
        {
            authenticatorData: Iterable<number, any, any> & { length: number };
            clientDataJson: string;
            userSignature: Iterable<number, any, any> & { length: number };
        },
    >;
    ProgrammableMoveCall: BcsType<
        {
            arguments: EnumOutputShapeWithKeys<
                {
                    GasCoin: true;
                    Input: number;
                    NestedResult: [number, number];
                    Result: number;
                },
                "GasCoin"
                | "Input"
                | "Result"
                | "NestedResult",
            >[];
            function: string;
            module: string;
            package: string;
            typeArguments: string[];
        },
        {
            arguments: Iterable<
                EnumInputShape<
                    {
                        GasCoin: null
                        | boolean
                        | object;
                        Input: number;
                        NestedResult: readonly [number, number];
                        Result: number;
                    },
                >,
                any,
                any,
            > & { length: number };
            function: string;
            module: string;
            package: string | Uint8Array<ArrayBufferLike>;
            typeArguments: Iterable<string | TypeTag, any, any> & { length: number };
        },
    >;
    ProgrammableTransaction: BcsType<
        {
            commands: EnumOutputShapeWithKeys<
                {
                    MakeMoveVec: {
                        elements: EnumOutputShapeWithKeys<
                            {
                                GasCoin: true;
                                Input: number;
                                NestedResult: [(...), (...)];
                                Result: number;
                            },
                            "GasCoin"
                            | "Input"
                            | "Result"
                            | "NestedResult",
                        >[];
                        type: null | string;
                    };
                    MergeCoins: {
                        destination: EnumOutputShapeWithKeys<
                            {
                                GasCoin: true;
                                Input: number;
                                NestedResult: [number, number];
                                Result: number;
                            },
                            "GasCoin"
                            | "Input"
                            | "Result"
                            | "NestedResult",
                        >;
                        sources: EnumOutputShapeWithKeys<
                            {
                                GasCoin: true;
                                Input: number;
                                NestedResult: [(...), (...)];
                                Result: number;
                            },
                            "GasCoin"
                            | "Input"
                            | "Result"
                            | "NestedResult",
                        >[];
                    };
                    MoveCall: {
                        arguments: EnumOutputShapeWithKeys<
                            {
                                GasCoin: true;
                                Input: number;
                                NestedResult: [(...), (...)];
                                Result: number;
                            },
                            "GasCoin"
                            | "Input"
                            | "Result"
                            | "NestedResult",
                        >[];
                        function: string;
                        module: string;
                        package: string;
                        typeArguments: string[];
                    };
                    Publish: { dependencies: string[]; modules: string[] };
                    SplitCoins: {
                        amounts: EnumOutputShapeWithKeys<
                            {
                                GasCoin: true;
                                Input: number;
                                NestedResult: [(...), (...)];
                                Result: number;
                            },
                            "GasCoin"
                            | "Input"
                            | "Result"
                            | "NestedResult",
                        >[];
                        coin: EnumOutputShapeWithKeys<
                            {
                                GasCoin: true;
                                Input: number;
                                NestedResult: [number, number];
                                Result: number;
                            },
                            "GasCoin"
                            | "Input"
                            | "Result"
                            | "NestedResult",
                        >;
                    };
                    TransferObjects: {
                        address: EnumOutputShapeWithKeys<
                            {
                                GasCoin: true;
                                Input: number;
                                NestedResult: [number, number];
                                Result: number;
                            },
                            "GasCoin"
                            | "Input"
                            | "Result"
                            | "NestedResult",
                        >;
                        objects: EnumOutputShapeWithKeys<
                            {
                                GasCoin: true;
                                Input: number;
                                NestedResult: [(...), (...)];
                                Result: number;
                            },
                            "GasCoin"
                            | "Input"
                            | "Result"
                            | "NestedResult",
                        >[];
                    };
                    Upgrade: {
                        dependencies: string[];
                        modules: string[];
                        package: string;
                        ticket: EnumOutputShapeWithKeys<
                            {
                                GasCoin: true;
                                Input: number;
                                NestedResult: [number, number];
                                Result: number;
                            },
                            "GasCoin"
                            | "Input"
                            | "Result"
                            | "NestedResult",
                        >;
                    };
                },
                | "MoveCall"
                | "TransferObjects"
                | "SplitCoins"
                | "MergeCoins"
                | "Publish"
                | "MakeMoveVec"
                | "Upgrade",
            >[];
            inputs: EnumOutputShapeWithKeys<
                {
                    Object: EnumOutputShapeWithKeys<
                        {
                            ImmOrOwnedObject: {
                                digest: string;
                                objectId: string;
                                version: string;
                            };
                            Receiving: { digest: string; objectId: string; version: string };
                            SharedObject: {
                                initialSharedVersion: string;
                                mutable: boolean;
                                objectId: string;
                            };
                        },
                        "ImmOrOwnedObject"
                        | "SharedObject"
                        | "Receiving",
                    >;
                    Pure: { bytes: string };
                },
                "Pure"
                | "Object",
            >[];
        },
        {
            commands: Iterable<
                EnumInputShape<
                    {
                        MakeMoveVec: {
                            elements: Iterable<EnumInputShape<(...)>, any, any> & {
                                length: number;
                            };
                            type: null
                            | string;
                        };
                        MergeCoins: {
                            destination: EnumInputShape<
                                {
                                    GasCoin: (...)
                                    | (...)
                                    | (...)
                                    | (...);
                                    Input: number;
                                    NestedResult: readonly [(...), (...)];
                                    Result: number;
                                },
                            >;
                            sources: Iterable<EnumInputShape<(...)>, any, any> & {
                                length: number;
                            };
                        };
                        MoveCall: {
                            arguments: Iterable<EnumInputShape<(...)>, any, any> & {
                                length: number;
                            };
                            function: string;
                            module: string;
                            package: string
                            | Uint8Array<ArrayBufferLike>;
                            typeArguments: Iterable<(...) | (...), any, any> & { length: number };
                        };
                        Publish: {
                            dependencies: Iterable<(...) | (...), any, any> & {
                                length: number;
                            };
                            modules: Iterable<(...) | (...), any, any> & { length: number };
                        };
                        SplitCoins: {
                            amounts: Iterable<EnumInputShape<(...)>, any, any> & {
                                length: number;
                            };
                            coin: EnumInputShape<
                                {
                                    GasCoin: (...)
                                    | (...)
                                    | (...)
                                    | (...);
                                    Input: number;
                                    NestedResult: readonly [(...), (...)];
                                    Result: number;
                                },
                            >;
                        };
                        TransferObjects: {
                            address: EnumInputShape<
                                {
                                    GasCoin: (...)
                                    | (...)
                                    | (...)
                                    | (...);
                                    Input: number;
                                    NestedResult: readonly [(...), (...)];
                                    Result: number;
                                },
                            >;
                            objects: Iterable<EnumInputShape<(...)>, any, any> & {
                                length: number;
                            };
                        };
                        Upgrade: {
                            dependencies: Iterable<(...) | (...), any, any> & {
                                length: number;
                            };
                            modules: Iterable<(...) | (...), any, any> & { length: number };
                            package: string | Uint8Array<ArrayBufferLike>;
                            ticket: EnumInputShape<
                                {
                                    GasCoin: (...)
                                    | (...)
                                    | (...)
                                    | (...);
                                    Input: number;
                                    NestedResult: readonly [(...), (...)];
                                    Result: number;
                                },
                            >;
                        };
                    },
                >,
                any,
                any,
            > & { length: number };
            inputs: Iterable<
                EnumInputShape<
                    {
                        Object: EnumInputShape<
                            {
                                ImmOrOwnedObject: {
                                    digest: string;
                                    objectId: (...)
                                    | (...);
                                    version: (...) | (...) | (...);
                                };
                                Receiving: {
                                    digest: string;
                                    objectId: (...)
                                    | (...);
                                    version: (...) | (...) | (...);
                                };
                                SharedObject: {
                                    initialSharedVersion: (...)
                                    | (...)
                                    | (...);
                                    mutable: boolean;
                                    objectId: (...) | (...);
                                };
                            },
                        >;
                        Pure: { bytes: string
                        | Uint8Array<ArrayBufferLike> };
                    },
                >,
                any,
                any,
            > & { length: number };
        },
    >;
    PublicKey: BcsType<
        EnumOutputShapeWithKeys<
            {
                ED25519: number[];
                Secp256k1: number[];
                Secp256r1: number[];
                ZkLogin: number[];
            },
            "ED25519"
            | "Secp256k1"
            | "Secp256r1"
            | "ZkLogin",
        >,
        EnumInputShape<
            {
                ED25519: Iterable<number, any, any> & { length: number };
                Secp256k1: Iterable<number, any, any> & { length: number };
                Secp256r1: Iterable<number, any, any> & { length: number };
                ZkLogin: Iterable<number, any, any> & { length: number };
            },
        >,
    >;
    SenderSignedData: BcsType<
        {
            intentMessage: {
                intent: {
                    appId: { $kind: "Sui"; Sui: true };
                    scope: EnumOutputShapeWithKeys<
                        {
                            CheckpointSummary: true;
                            PersonalMessage: true;
                            TransactionData: true;
                            TransactionEffects: true;
                        },
                        | "TransactionData"
                        | "TransactionEffects"
                        | "CheckpointSummary"
                        | "PersonalMessage",
                    >;
                    version: { $kind: "V0"; V0: true };
                };
                value: {
                    $kind: "V1";
                    V1: {
                        expiration: EnumOutputShapeWithKeys<
                            { Epoch: number; None: true },
                            "None" | "Epoch",
                        >;
                        gasData: {
                            budget: string;
                            owner: string;
                            payment: { digest: string; objectId: string; version: string }[];
                            price: string;
                        };
                        kind: EnumOutputShapeWithKeys<
                            {
                                ChangeEpoch: true;
                                ConsensusCommitPrologue: true;
                                Genesis: true;
                                ProgrammableTransaction: { commands: (...)[]; inputs: (...)[] };
                            },
                            | "ProgrammableTransaction"
                            | "ChangeEpoch"
                            | "Genesis"
                            | "ConsensusCommitPrologue",
                        >;
                        sender: string;
                    };
                };
            };
            txSignatures: string[];
        }[],
        Iterable<
            {
                intentMessage: {
                    intent: {
                        appId: { Sui: null
                        | boolean
                        | object };
                        scope: EnumInputShape<
                            {
                                CheckpointSummary: null
                                | boolean
                                | object;
                                PersonalMessage: null | boolean | object;
                                TransactionData: null | boolean | object;
                                TransactionEffects: null | boolean | object;
                            },
                        >;
                        version: { V0: null
                        | boolean
                        | object };
                    };
                    value: {
                        V1: {
                            expiration: EnumInputShape<
                                { Epoch: (...)
                                | (...); None: (...) | (...) | (...) | (...) },
                            >;
                            gasData: {
                                budget: string | number | bigint;
                                owner: string | Uint8Array<(...)>;
                                payment: Iterable<(...), (...), (...)> & { length: ... };
                                price: string | number | bigint;
                            };
                            kind: EnumInputShape<
                                {
                                    ChangeEpoch: (...)
                                    | (...)
                                    | (...)
                                    | (...);
                                    ConsensusCommitPrologue: (...) | (...) | (...) | (...);
                                    Genesis: (...) | (...) | (...) | (...);
                                    ProgrammableTransaction: { commands: ...; inputs: ... };
                                },
                            >;
                            sender: string
                            | Uint8Array<ArrayBufferLike>;
                        };
                    };
                };
                txSignatures: Iterable<string | Uint8Array<ArrayBufferLike>, any, any> & {
                    length: number;
                };
            },
            any,
            any,
        > & { length: number },
    >;
    SenderSignedTransaction: BcsType<
        {
            intentMessage: {
                intent: {
                    appId: { $kind: "Sui"; Sui: true };
                    scope: EnumOutputShapeWithKeys<
                        {
                            CheckpointSummary: true;
                            PersonalMessage: true;
                            TransactionData: true;
                            TransactionEffects: true;
                        },
                        | "TransactionData"
                        | "TransactionEffects"
                        | "CheckpointSummary"
                        | "PersonalMessage",
                    >;
                    version: { $kind: "V0"; V0: true };
                };
                value: {
                    $kind: "V1";
                    V1: {
                        expiration: EnumOutputShapeWithKeys<
                            { Epoch: number; None: true },
                            "None" | "Epoch",
                        >;
                        gasData: {
                            budget: string;
                            owner: string;
                            payment: { digest: string; objectId: string; version: string }[];
                            price: string;
                        };
                        kind: EnumOutputShapeWithKeys<
                            {
                                ChangeEpoch: true;
                                ConsensusCommitPrologue: true;
                                Genesis: true;
                                ProgrammableTransaction: {
                                    commands: EnumOutputShapeWithKeys<(...), (...)>[];
                                    inputs: EnumOutputShapeWithKeys<(...), (...)>[];
                                };
                            },
                            | "ProgrammableTransaction"
                            | "ChangeEpoch"
                            | "Genesis"
                            | "ConsensusCommitPrologue",
                        >;
                        sender: string;
                    };
                };
            };
            txSignatures: string[];
        },
        {
            intentMessage: {
                intent: {
                    appId: { Sui: null
                    | boolean
                    | object };
                    scope: EnumInputShape<
                        {
                            CheckpointSummary: null
                            | boolean
                            | object;
                            PersonalMessage: null | boolean | object;
                            TransactionData: null | boolean | object;
                            TransactionEffects: null | boolean | object;
                        },
                    >;
                    version: { V0: null
                    | boolean
                    | object };
                };
                value: {
                    V1: {
                        expiration: EnumInputShape<
                            { Epoch: string
                            | number; None: null | boolean | object },
                        >;
                        gasData: {
                            budget: string | number | bigint;
                            owner: string | Uint8Array<ArrayBufferLike>;
                            payment: Iterable<
                                {
                                    digest: string;
                                    objectId: (...)
                                    | (...);
                                    version: (...) | (...) | (...);
                                },
                                any,
                                any,
                            > & { length: number };
                            price: string | number | bigint;
                        };
                        kind: EnumInputShape<
                            {
                                ChangeEpoch: null
                                | boolean
                                | object;
                                ConsensusCommitPrologue: null | boolean | object;
                                Genesis: null | boolean | object;
                                ProgrammableTransaction: {
                                    commands: Iterable<(...), (...), (...)> & { length: ... };
                                    inputs: Iterable<(...), (...), (...)> & { length: ... };
                                };
                            },
                        >;
                        sender: string
                        | Uint8Array<ArrayBufferLike>;
                    };
                };
            };
            txSignatures: Iterable<string | Uint8Array<ArrayBufferLike>, any, any> & {
                length: number;
            };
        },
    >;
    SharedObjectRef: BcsType<
        { initialSharedVersion: string; mutable: boolean; objectId: string },
        {
            initialSharedVersion: string | number | bigint;
            mutable: boolean;
            objectId: string | Uint8Array<ArrayBufferLike>;
        },
    >;
    String: BcsType<string, string>;
    StructTag: BcsType<
        {
            address: string;
            module: string;
            name: string;
            typeParams: TypeTag[];
        },
        {
            address: string
            | Uint8Array<ArrayBufferLike>;
            module: string;
            name: string;
            typeParams: Iterable<TypeTag, any, any> & { length: number };
        },
    >;
    SuiObjectRef: BcsType<
        { digest: string; objectId: string; version: string },
        {
            digest: string;
            objectId: string | Uint8Array<ArrayBufferLike>;
            version: string | number | bigint;
        },
    >;
    TransactionData: BcsType<
        {
            $kind: "V1";
            V1: {
                expiration: EnumOutputShapeWithKeys<
                    { Epoch: number; None: true },
                    "None" | "Epoch",
                >;
                gasData: {
                    budget: string;
                    owner: string;
                    payment: { digest: string; objectId: string; version: string }[];
                    price: string;
                };
                kind: EnumOutputShapeWithKeys<
                    {
                        ChangeEpoch: true;
                        ConsensusCommitPrologue: true;
                        Genesis: true;
                        ProgrammableTransaction: {
                            commands: EnumOutputShapeWithKeys<
                                {
                                    MakeMoveVec: { elements: ...; type: ... };
                                    MergeCoins: { destination: ...; sources: ... };
                                    MoveCall: {
                                        arguments: ...;
                                        function: ...;
                                        module: ...;
                                        package: ...;
                                        typeArguments: ...;
                                    };
                                    Publish: { dependencies: ...; modules: ... };
                                    SplitCoins: { amounts: ...; coin: ... };
                                    TransferObjects: { address: ...; objects: ... };
                                    Upgrade: {
                                        dependencies: ...;
                                        modules: ...;
                                        package: ...;
                                        ticket: ...;
                                    };
                                },
                                | "MoveCall"
                                | "TransferObjects"
                                | "SplitCoins"
                                | "MergeCoins"
                                | "Publish"
                                | "MakeMoveVec"
                                | "Upgrade",
                            >[];
                            inputs: EnumOutputShapeWithKeys<
                                {
                                    Object: EnumOutputShapeWithKeys<(...), (...)>;
                                    Pure: { bytes: ... };
                                },
                                "Pure"
                                | "Object",
                            >[];
                        };
                    },
                    | "ProgrammableTransaction"
                    | "ChangeEpoch"
                    | "Genesis"
                    | "ConsensusCommitPrologue",
                >;
                sender: string;
            };
        },
        {
            V1: {
                expiration: EnumInputShape<
                    { Epoch: string
                    | number; None: null | boolean | object },
                >;
                gasData: {
                    budget: string | number | bigint;
                    owner: string | Uint8Array<ArrayBufferLike>;
                    payment: Iterable<
                        {
                            digest: string;
                            objectId: string
                            | Uint8Array<ArrayBufferLike>;
                            version: string | number | bigint;
                        },
                        any,
                        any,
                    > & { length: number };
                    price: string | number | bigint;
                };
                kind: EnumInputShape<
                    {
                        ChangeEpoch: null
                        | boolean
                        | object;
                        ConsensusCommitPrologue: null | boolean | object;
                        Genesis: null | boolean | object;
                        ProgrammableTransaction: {
                            commands: Iterable<
                                EnumInputShape<
                                    {
                                        MakeMoveVec: ...;
                                        MergeCoins: ...;
                                        MoveCall: ...;
                                        Publish: ...;
                                        SplitCoins: ...;
                                        TransferObjects: ...;
                                        Upgrade: ...;
                                    },
                                >,
                                any,
                                any,
                            > & { length: number };
                            inputs: Iterable<
                                EnumInputShape<{ Object: ...; Pure: ... }>,
                                any,
                                any,
                            > & { length: number };
                        };
                    },
                >;
                sender: string
                | Uint8Array<ArrayBufferLike>;
            };
        },
    >;
    TransactionDataV1: BcsType<
        {
            expiration: EnumOutputShapeWithKeys<
                { Epoch: number; None: true },
                "None" | "Epoch",
            >;
            gasData: {
                budget: string;
                owner: string;
                payment: { digest: string; objectId: string; version: string }[];
                price: string;
            };
            kind: EnumOutputShapeWithKeys<
                {
                    ChangeEpoch: true;
                    ConsensusCommitPrologue: true;
                    Genesis: true;
                    ProgrammableTransaction: {
                        commands: EnumOutputShapeWithKeys<
                            {
                                MakeMoveVec: { elements: (...)[]; type: (...) | (...) };
                                MergeCoins: {
                                    destination: EnumOutputShapeWithKeys<(...), (...)>;
                                    sources: (...)[];
                                };
                                MoveCall: {
                                    arguments: (...)[];
                                    function: string;
                                    module: string;
                                    package: string;
                                    typeArguments: (...)[];
                                };
                                Publish: { dependencies: (...)[]; modules: (...)[] };
                                SplitCoins: {
                                    amounts: (...)[];
                                    coin: EnumOutputShapeWithKeys<(...), (...)>;
                                };
                                TransferObjects: {
                                    address: EnumOutputShapeWithKeys<(...), (...)>;
                                    objects: (...)[];
                                };
                                Upgrade: {
                                    dependencies: (...)[];
                                    modules: (...)[];
                                    package: string;
                                    ticket: EnumOutputShapeWithKeys<(...), (...)>;
                                };
                            },
                            | "MoveCall"
                            | "TransferObjects"
                            | "SplitCoins"
                            | "MergeCoins"
                            | "Publish"
                            | "MakeMoveVec"
                            | "Upgrade",
                        >[];
                        inputs: EnumOutputShapeWithKeys<
                            {
                                Object: EnumOutputShapeWithKeys<
                                    { ImmOrOwnedObject: ...; Receiving: ...; SharedObject: ... },
                                    (...) | (...) | (...),
                                >;
                                Pure: { bytes: string };
                            },
                            "Pure"
                            | "Object",
                        >[];
                    };
                },
                | "ProgrammableTransaction"
                | "ChangeEpoch"
                | "Genesis"
                | "ConsensusCommitPrologue",
            >;
            sender: string;
        },
        {
            expiration: EnumInputShape<
                { Epoch: string
                | number; None: null | boolean | object },
            >;
            gasData: {
                budget: string | number | bigint;
                owner: string | Uint8Array<ArrayBufferLike>;
                payment: Iterable<
                    {
                        digest: string;
                        objectId: string
                        | Uint8Array<ArrayBufferLike>;
                        version: string | number | bigint;
                    },
                    any,
                    any,
                > & { length: number };
                price: string | number | bigint;
            };
            kind: EnumInputShape<
                {
                    ChangeEpoch: null
                    | boolean
                    | object;
                    ConsensusCommitPrologue: null | boolean | object;
                    Genesis: null | boolean | object;
                    ProgrammableTransaction: {
                        commands: Iterable<
                            EnumInputShape<
                                {
                                    MakeMoveVec: { elements: ...; type: ... };
                                    MergeCoins: { destination: ...; sources: ... };
                                    MoveCall: {
                                        arguments: ...;
                                        function: ...;
                                        module: ...;
                                        package: ...;
                                        typeArguments: ...;
                                    };
                                    Publish: { dependencies: ...; modules: ... };
                                    SplitCoins: { amounts: ...; coin: ... };
                                    TransferObjects: { address: ...; objects: ... };
                                    Upgrade: {
                                        dependencies: ...;
                                        modules: ...;
                                        package: ...;
                                        ticket: ...;
                                    };
                                },
                            >,
                            any,
                            any,
                        > & { length: number };
                        inputs: Iterable<
                            EnumInputShape<
                                { Object: EnumInputShape<(...)>; Pure: { bytes: ... } },
                            >,
                            any,
                            any,
                        > & { length: number };
                    };
                },
            >;
            sender: string
            | Uint8Array<ArrayBufferLike>;
        },
    >;
    TransactionEffects: BcsType<
        EnumOutputShapeWithKeys<
            {
                V1: {
                    created: [
                        { digest: string; objectId: string; version: string },
                        EnumOutputShapeWithKeys<
                            {
                                AddressOwner: string;
                                ConsensusV2: {
                                    authenticator: { $kind: ...; SingleOwner: ... };
                                    startVersion: string;
                                };
                                Immutable: true;
                                ObjectOwner: string;
                                Shared: { initialSharedVersion: string };
                            },
                            | "AddressOwner"
                            | "ObjectOwner"
                            | "Shared"
                            | "Immutable"
                            | "ConsensusV2",
                        >,
                    ][];
                    deleted: { digest: string; objectId: string; version: string }[];
                    dependencies: string[];
                    eventsDigest: null | string;
                    executedEpoch: string;
                    gasObject: [
                        { digest: string; objectId: string; version: string },
                        EnumOutputShapeWithKeys<
                            {
                                AddressOwner: string;
                                ConsensusV2: {
                                    authenticator: { $kind: "SingleOwner"; SingleOwner: string };
                                    startVersion: string;
                                };
                                Immutable: true;
                                ObjectOwner: string;
                                Shared: { initialSharedVersion: string };
                            },
                            | "AddressOwner"
                            | "ObjectOwner"
                            | "Shared"
                            | "Immutable"
                            | "ConsensusV2",
                        >,
                    ];
                    gasUsed: {
                        computationCost: string;
                        nonRefundableStorageFee: string;
                        storageCost: string;
                        storageRebate: string;
                    };
                    modifiedAtVersions: [string, string][];
                    mutated: [
                        { digest: string; objectId: string; version: string },
                        EnumOutputShapeWithKeys<
                            {
                                AddressOwner: string;
                                ConsensusV2: {
                                    authenticator: { $kind: ...; SingleOwner: ... };
                                    startVersion: string;
                                };
                                Immutable: true;
                                ObjectOwner: string;
                                Shared: { initialSharedVersion: string };
                            },
                            | "AddressOwner"
                            | "ObjectOwner"
                            | "Shared"
                            | "Immutable"
                            | "ConsensusV2",
                        >,
                    ][];
                    sharedObjects: { digest: string; objectId: string; version: string }[];
                    status: EnumOutputShapeWithKeys<
                        {
                            Failed: {
                                command: null
                                | string;
                                error: EnumOutputShapeWithKeys<
                                    {
                                        AddressDeniedForCoin: { address: ...; coinType: ... };
                                        ArityMismatch: true;
                                        CertificateDenied: true;
                                        CircularObjectOwnership: { object: ... };
                                        CoinBalanceOverflow: true;
                                        CoinTypeGlobalPause: { coinType: ... };
                                        CommandArgumentError: { argIdx: ...; kind: ... };
                                        EffectsTooLarge: { currentSize: ...; maxSize: ... };
                                        ExecutionCancelledDueToRandomnessUnavailable: true;
                                        ExecutionCancelledDueToSharedObjectCongestion: {
                                            congestedObjects: ...;
                                        };
                                        FeatureNotYetSupported: true;
                                        FunctionNotFound: true;
                                        InputObjectDeleted: true;
                                        InsufficientCoinBalance: true;
                                        InsufficientGas: true;
                                        InvalidGasObject: true;
                                        InvalidPublicFunctionReturnType: { idx: ... };
                                        InvalidTransferObject: true;
                                        InvariantViolation: true;
                                        MoveAbort: [(...), (...)];
                                        MoveObjectTooBig: { maxObjectSize: ...; objectSize: ... };
                                        MovePackageTooBig: { maxObjectSize: ...; objectSize: ... };
                                        MovePrimitiveRuntimeError: (...) | (...);
                                        NonEntryFunctionInvoked: true;
                                        PackageUpgradeError: { upgradeError: ... };
                                        PublishErrorNonZeroAddress: true;
                                        PublishUpgradeDependencyDowngrade: true;
                                        PublishUpgradeMissingDependency: true;
                                        SharedObjectOperationNotAllowed: true;
                                        SuiMoveVerificationError: true;
                                        SuiMoveVerificationTimedout: true;
                                        TypeArgumentError: { argumentIdx: ...; kind: ... };
                                        TypeArityMismatch: true;
                                        UnusedValueWithoutDrop: { resultIdx: ...; secondaryIdx: ... };
                                        VMInvariantViolation: true;
                                        VMVerificationOrDeserializationError: true;
                                        WrittenObjectsTooLarge: { currentSize: ...; maxSize: ... };
                                    },
                                    | "PackageUpgradeError"
                                    | "SharedObjectOperationNotAllowed"
                                    | "CommandArgumentError"
                                    | "TypeArgumentError"
                                    | "InsufficientGas"
                                    | "InvalidGasObject"
                                    | "InvariantViolation"
                                    | "FeatureNotYetSupported"
                                    | "MoveObjectTooBig"
                                    | "MovePackageTooBig"
                                    | "CircularObjectOwnership"
                                    | "InsufficientCoinBalance"
                                    | "CoinBalanceOverflow"
                                    | "PublishErrorNonZeroAddress"
                                    | "SuiMoveVerificationError"
                                    | "MovePrimitiveRuntimeError"
                                    | "MoveAbort"
                                    | "VMVerificationOrDeserializationError"
                                    | "VMInvariantViolation"
                                    | "FunctionNotFound"
                                    | "ArityMismatch"
                                    | "TypeArityMismatch"
                                    | "NonEntryFunctionInvoked"
                                    | "UnusedValueWithoutDrop"
                                    | "InvalidPublicFunctionReturnType"
                                    | "InvalidTransferObject"
                                    | "EffectsTooLarge"
                                    | "PublishUpgradeMissingDependency"
                                    | "PublishUpgradeDependencyDowngrade"
                                    | "WrittenObjectsTooLarge"
                                    | "CertificateDenied"
                                    | "SuiMoveVerificationTimedout"
                                    | "InputObjectDeleted"
                                    | "ExecutionCancelledDueToSharedObjectCongestion"
                                    | "AddressDeniedForCoin"
                                    | "CoinTypeGlobalPause"
                                    | "ExecutionCancelledDueToRandomnessUnavailable",
                                >;
                            };
                            Success: true;
                        },
                        "Success"
                        | "Failed",
                    >;
                    transactionDigest: string;
                    unwrapped: [
                        { digest: string; objectId: string; version: string },
                        EnumOutputShapeWithKeys<
                            {
                                AddressOwner: string;
                                ConsensusV2: {
                                    authenticator: { $kind: ...; SingleOwner: ... };
                                    startVersion: string;
                                };
                                Immutable: true;
                                ObjectOwner: string;
                                Shared: { initialSharedVersion: string };
                            },
                            | "AddressOwner"
                            | "ObjectOwner"
                            | "Shared"
                            | "Immutable"
                            | "ConsensusV2",
                        >,
                    ][];
                    unwrappedThenDeleted: {
                        digest: string;
                        objectId: string;
                        version: string;
                    }[];
                    wrapped: { digest: string; objectId: string; version: string }[];
                };
                V2: {
                    auxDataDigest: null
                    | string;
                    changedObjects: [
                        string,
                        {
                            idOperation: EnumOutputShapeWithKeys<
                                { Created: true; Deleted: true; None: true },
                                "None" | "Created" | "Deleted",
                            >;
                            inputState: EnumOutputShapeWithKeys<
                                { Exist: [(...), (...)]; NotExist: true },
                                "NotExist" | "Exist",
                            >;
                            outputState: EnumOutputShapeWithKeys<
                                {
                                    NotExist: true;
                                    ObjectWrite: [(...), (...)];
                                    PackageWrite: [(...), (...)];
                                },
                                "NotExist"
                                | "ObjectWrite"
                                | "PackageWrite",
                            >;
                        },
                    ][];
                    dependencies: string[];
                    eventsDigest: null
                    | string;
                    executedEpoch: string;
                    gasObjectIndex: null | number;
                    gasUsed: {
                        computationCost: string;
                        nonRefundableStorageFee: string;
                        storageCost: string;
                        storageRebate: string;
                    };
                    lamportVersion: string;
                    status: EnumOutputShapeWithKeys<
                        {
                            Failed: {
                                command: null
                                | string;
                                error: EnumOutputShapeWithKeys<
                                    {
                                        AddressDeniedForCoin: { address: ...; coinType: ... };
                                        ArityMismatch: true;
                                        CertificateDenied: true;
                                        CircularObjectOwnership: { object: ... };
                                        CoinBalanceOverflow: true;
                                        CoinTypeGlobalPause: { coinType: ... };
                                        CommandArgumentError: { argIdx: ...; kind: ... };
                                        EffectsTooLarge: { currentSize: ...; maxSize: ... };
                                        ExecutionCancelledDueToRandomnessUnavailable: true;
                                        ExecutionCancelledDueToSharedObjectCongestion: {
                                            congestedObjects: ...;
                                        };
                                        FeatureNotYetSupported: true;
                                        FunctionNotFound: true;
                                        InputObjectDeleted: true;
                                        InsufficientCoinBalance: true;
                                        InsufficientGas: true;
                                        InvalidGasObject: true;
                                        InvalidPublicFunctionReturnType: { idx: ... };
                                        InvalidTransferObject: true;
                                        InvariantViolation: true;
                                        MoveAbort: [(...), (...)];
                                        MoveObjectTooBig: { maxObjectSize: ...; objectSize: ... };
                                        MovePackageTooBig: { maxObjectSize: ...; objectSize: ... };
                                        MovePrimitiveRuntimeError: (...) | (...);
                                        NonEntryFunctionInvoked: true;
                                        PackageUpgradeError: { upgradeError: ... };
                                        PublishErrorNonZeroAddress: true;
                                        PublishUpgradeDependencyDowngrade: true;
                                        PublishUpgradeMissingDependency: true;
                                        SharedObjectOperationNotAllowed: true;
                                        SuiMoveVerificationError: true;
                                        SuiMoveVerificationTimedout: true;
                                        TypeArgumentError: { argumentIdx: ...; kind: ... };
                                        TypeArityMismatch: true;
                                        UnusedValueWithoutDrop: { resultIdx: ...; secondaryIdx: ... };
                                        VMInvariantViolation: true;
                                        VMVerificationOrDeserializationError: true;
                                        WrittenObjectsTooLarge: { currentSize: ...; maxSize: ... };
                                    },
                                    | "PackageUpgradeError"
                                    | "SharedObjectOperationNotAllowed"
                                    | "CommandArgumentError"
                                    | "TypeArgumentError"
                                    | "InsufficientGas"
                                    | "InvalidGasObject"
                                    | "InvariantViolation"
                                    | "FeatureNotYetSupported"
                                    | "MoveObjectTooBig"
                                    | "MovePackageTooBig"
                                    | "CircularObjectOwnership"
                                    | "InsufficientCoinBalance"
                                    | "CoinBalanceOverflow"
                                    | "PublishErrorNonZeroAddress"
                                    | "SuiMoveVerificationError"
                                    | "MovePrimitiveRuntimeError"
                                    | "MoveAbort"
                                    | "VMVerificationOrDeserializationError"
                                    | "VMInvariantViolation"
                                    | "FunctionNotFound"
                                    | "ArityMismatch"
                                    | "TypeArityMismatch"
                                    | "NonEntryFunctionInvoked"
                                    | "UnusedValueWithoutDrop"
                                    | "InvalidPublicFunctionReturnType"
                                    | "InvalidTransferObject"
                                    | "EffectsTooLarge"
                                    | "PublishUpgradeMissingDependency"
                                    | "PublishUpgradeDependencyDowngrade"
                                    | "WrittenObjectsTooLarge"
                                    | "CertificateDenied"
                                    | "SuiMoveVerificationTimedout"
                                    | "InputObjectDeleted"
                                    | "ExecutionCancelledDueToSharedObjectCongestion"
                                    | "AddressDeniedForCoin"
                                    | "CoinTypeGlobalPause"
                                    | "ExecutionCancelledDueToRandomnessUnavailable",
                                >;
                            };
                            Success: true;
                        },
                        "Success"
                        | "Failed",
                    >;
                    transactionDigest: string;
                    unchangedSharedObjects: [
                        string,
                        EnumOutputShapeWithKeys<
                            {
                                Cancelled: string;
                                MutateDeleted: string;
                                PerEpochConfig: true;
                                ReadDeleted: string;
                                ReadOnlyRoot: [string, string];
                            },
                            | "ReadOnlyRoot"
                            | "MutateDeleted"
                            | "ReadDeleted"
                            | "Cancelled"
                            | "PerEpochConfig",
                        >,
                    ][];
                };
            },
            "V1"
            | "V2",
        >,
        EnumInputShape<
            {
                V1: {
                    created: Iterable<
                        readonly [
                            {
                                digest: string;
                                objectId: string
                                | Uint8Array<(...)>;
                                version: string | number | bigint;
                            },
                            EnumInputShape<
                                {
                                    AddressOwner: (...)
                                    | (...);
                                    ConsensusV2: { authenticator: ...; startVersion: ... };
                                    Immutable: (...) | (...) | (...) | (...);
                                    ObjectOwner: (...) | (...);
                                    Shared: { initialSharedVersion: ... };
                                },
                            >,
                        ],
                        any,
                        any,
                    > & { length: number };
                    deleted: Iterable<
                        {
                            digest: string;
                            objectId: string
                            | Uint8Array<ArrayBufferLike>;
                            version: string | number | bigint;
                        },
                        any,
                        any,
                    > & { length: number };
                    dependencies: Iterable<string, any, any> & { length: number };
                    eventsDigest: undefined | null | string;
                    executedEpoch: string | number | bigint;
                    gasObject: readonly [
                        {
                            digest: string;
                            objectId: string
                            | Uint8Array<ArrayBufferLike>;
                            version: string | number | bigint;
                        },
                        EnumInputShape<
                            {
                                AddressOwner: string
                                | Uint8Array<ArrayBufferLike>;
                                ConsensusV2: {
                                    authenticator: { SingleOwner: (...) | (...) };
                                    startVersion: string | number | bigint;
                                };
                                Immutable: null
                                | boolean
                                | object;
                                ObjectOwner: string | Uint8Array<ArrayBufferLike>;
                                Shared: { initialSharedVersion: string | number | bigint };
                            },
                        >,
                    ];
                    gasUsed: {
                        computationCost: string
                        | number
                        | bigint;
                        nonRefundableStorageFee: string | number | bigint;
                        storageCost: string | number | bigint;
                        storageRebate: string | number | bigint;
                    };
                    modifiedAtVersions: Iterable<
                        readonly [
                            string
                            | Uint8Array<ArrayBufferLike>,
                            string | number | bigint,
                        ],
                        any,
                        any,
                    > & { length: number };
                    mutated: Iterable<
                        readonly [
                            {
                                digest: string;
                                objectId: string
                                | Uint8Array<(...)>;
                                version: string | number | bigint;
                            },
                            EnumInputShape<
                                {
                                    AddressOwner: (...)
                                    | (...);
                                    ConsensusV2: { authenticator: ...; startVersion: ... };
                                    Immutable: (...) | (...) | (...) | (...);
                                    ObjectOwner: (...) | (...);
                                    Shared: { initialSharedVersion: ... };
                                },
                            >,
                        ],
                        any,
                        any,
                    > & { length: number };
                    sharedObjects: Iterable<
                        {
                            digest: string;
                            objectId: string
                            | Uint8Array<ArrayBufferLike>;
                            version: string | number | bigint;
                        },
                        any,
                        any,
                    > & { length: number };
                    status: EnumInputShape<
                        {
                            Failed: {
                                command: undefined
                                | null
                                | string
                                | number
                                | bigint;
                                error: EnumInputShape<
                                    {
                                        AddressDeniedForCoin: { address: ...; coinType: ... };
                                        ArityMismatch: (...) | (...) | (...) | (...);
                                        CertificateDenied: (...) | (...) | (...) | (...);
                                        CircularObjectOwnership: { object: ... };
                                        CoinBalanceOverflow: (...) | (...) | (...) | (...);
                                        CoinTypeGlobalPause: { coinType: ... };
                                        CommandArgumentError: { argIdx: ...; kind: ... };
                                        EffectsTooLarge: { currentSize: ...; maxSize: ... };
                                        ExecutionCancelledDueToRandomnessUnavailable:
                                            | (...)
                                            | (...)
                                            | (...)
                                            | (...);
                                        ExecutionCancelledDueToSharedObjectCongestion: {
                                            congestedObjects: ...;
                                        };
                                        FeatureNotYetSupported: (...)
                                        | (...)
                                        | (...)
                                        | (...);
                                        FunctionNotFound: (...) | (...) | (...) | (...);
                                        InputObjectDeleted: (...) | (...) | (...) | (...);
                                        InsufficientCoinBalance: (...) | (...) | (...) | (...);
                                        InsufficientGas: (...) | (...) | (...) | (...);
                                        InvalidGasObject: (...) | (...) | (...) | (...);
                                        InvalidPublicFunctionReturnType: { idx: ... };
                                        InvalidTransferObject: (...) | (...) | (...) | (...);
                                        InvariantViolation: (...) | (...) | (...) | (...);
                                        MoveAbort: readonly [(...), (...)];
                                        MoveObjectTooBig: { maxObjectSize: ...; objectSize: ... };
                                        MovePackageTooBig: { maxObjectSize: ...; objectSize: ... };
                                        MovePrimitiveRuntimeError: (...) | (...) | (...);
                                        NonEntryFunctionInvoked: (...) | (...) | (...) | (...);
                                        PackageUpgradeError: { upgradeError: ... };
                                        PublishErrorNonZeroAddress: (...) | (...) | (...) | (...);
                                        PublishUpgradeDependencyDowngrade: (...) | (...) | (...) | (...);
                                        PublishUpgradeMissingDependency: (...) | (...) | (...) | (...);
                                        SharedObjectOperationNotAllowed: (...) | (...) | (...) | (...);
                                        SuiMoveVerificationError: (...) | (...) | (...) | (...);
                                        SuiMoveVerificationTimedout: (...) | (...) | (...) | (...);
                                        TypeArgumentError: { argumentIdx: ...; kind: ... };
                                        TypeArityMismatch: (...) | (...) | (...) | (...);
                                        UnusedValueWithoutDrop: { resultIdx: ...; secondaryIdx: ... };
                                        VMInvariantViolation: (...) | (...) | (...) | (...);
                                        VMVerificationOrDeserializationError:
                                            | (...)
                                            | (...)
                                            | (...)
                                            | (...);
                                        WrittenObjectsTooLarge: { currentSize: ...; maxSize: ... };
                                    },
                                >;
                            };
                            Success: null
                            | boolean
                            | object;
                        },
                    >;
                    transactionDigest: string;
                    unwrapped: Iterable<
                        readonly [
                            {
                                digest: string;
                                objectId: string
                                | Uint8Array<(...)>;
                                version: string | number | bigint;
                            },
                            EnumInputShape<
                                {
                                    AddressOwner: (...)
                                    | (...);
                                    ConsensusV2: { authenticator: ...; startVersion: ... };
                                    Immutable: (...) | (...) | (...) | (...);
                                    ObjectOwner: (...) | (...);
                                    Shared: { initialSharedVersion: ... };
                                },
                            >,
                        ],
                        any,
                        any,
                    > & { length: number };
                    unwrappedThenDeleted: Iterable<
                        {
                            digest: string;
                            objectId: string
                            | Uint8Array<ArrayBufferLike>;
                            version: string | number | bigint;
                        },
                        any,
                        any,
                    > & { length: number };
                    wrapped: Iterable<
                        {
                            digest: string;
                            objectId: string
                            | Uint8Array<ArrayBufferLike>;
                            version: string | number | bigint;
                        },
                        any,
                        any,
                    > & { length: number };
                };
                V2: {
                    auxDataDigest: undefined
                    | null
                    | string;
                    changedObjects: Iterable<
                        readonly [
                            string
                            | Uint8Array<ArrayBufferLike>,
                            {
                                idOperation: EnumInputShape<
                                    { Created: ...; Deleted: ...; None: ... },
                                >;
                                inputState: EnumInputShape<{ Exist: ...; NotExist: ... }>;
                                outputState: EnumInputShape<
                                    { NotExist: ...; ObjectWrite: ...; PackageWrite: ... },
                                >;
                            },
                        ],
                        any,
                        any,
                    > & { length: number };
                    dependencies: Iterable<string, any, any> & { length: number };
                    eventsDigest: undefined | null | string;
                    executedEpoch: string | number | bigint;
                    gasObjectIndex: undefined | null | number;
                    gasUsed: {
                        computationCost: string | number | bigint;
                        nonRefundableStorageFee: string | number | bigint;
                        storageCost: string | number | bigint;
                        storageRebate: string | number | bigint;
                    };
                    lamportVersion: string
                    | number
                    | bigint;
                    status: EnumInputShape<
                        {
                            Failed: {
                                command: undefined
                                | null
                                | string
                                | number
                                | bigint;
                                error: EnumInputShape<
                                    {
                                        AddressDeniedForCoin: { address: ...; coinType: ... };
                                        ArityMismatch: (...) | (...) | (...) | (...);
                                        CertificateDenied: (...) | (...) | (...) | (...);
                                        CircularObjectOwnership: { object: ... };
                                        CoinBalanceOverflow: (...) | (...) | (...) | (...);
                                        CoinTypeGlobalPause: { coinType: ... };
                                        CommandArgumentError: { argIdx: ...; kind: ... };
                                        EffectsTooLarge: { currentSize: ...; maxSize: ... };
                                        ExecutionCancelledDueToRandomnessUnavailable:
                                            | (...)
                                            | (...)
                                            | (...)
                                            | (...);
                                        ExecutionCancelledDueToSharedObjectCongestion: {
                                            congestedObjects: ...;
                                        };
                                        FeatureNotYetSupported: (...)
                                        | (...)
                                        | (...)
                                        | (...);
                                        FunctionNotFound: (...) | (...) | (...) | (...);
                                        InputObjectDeleted: (...) | (...) | (...) | (...);
                                        InsufficientCoinBalance: (...) | (...) | (...) | (...);
                                        InsufficientGas: (...) | (...) | (...) | (...);
                                        InvalidGasObject: (...) | (...) | (...) | (...);
                                        InvalidPublicFunctionReturnType: { idx: ... };
                                        InvalidTransferObject: (...) | (...) | (...) | (...);
                                        InvariantViolation: (...) | (...) | (...) | (...);
                                        MoveAbort: readonly [(...), (...)];
                                        MoveObjectTooBig: { maxObjectSize: ...; objectSize: ... };
                                        MovePackageTooBig: { maxObjectSize: ...; objectSize: ... };
                                        MovePrimitiveRuntimeError: (...) | (...) | (...);
                                        NonEntryFunctionInvoked: (...) | (...) | (...) | (...);
                                        PackageUpgradeError: { upgradeError: ... };
                                        PublishErrorNonZeroAddress: (...) | (...) | (...) | (...);
                                        PublishUpgradeDependencyDowngrade: (...) | (...) | (...) | (...);
                                        PublishUpgradeMissingDependency: (...) | (...) | (...) | (...);
                                        SharedObjectOperationNotAllowed: (...) | (...) | (...) | (...);
                                        SuiMoveVerificationError: (...) | (...) | (...) | (...);
                                        SuiMoveVerificationTimedout: (...) | (...) | (...) | (...);
                                        TypeArgumentError: { argumentIdx: ...; kind: ... };
                                        TypeArityMismatch: (...) | (...) | (...) | (...);
                                        UnusedValueWithoutDrop: { resultIdx: ...; secondaryIdx: ... };
                                        VMInvariantViolation: (...) | (...) | (...) | (...);
                                        VMVerificationOrDeserializationError:
                                            | (...)
                                            | (...)
                                            | (...)
                                            | (...);
                                        WrittenObjectsTooLarge: { currentSize: ...; maxSize: ... };
                                    },
                                >;
                            };
                            Success: null
                            | boolean
                            | object;
                        },
                    >;
                    transactionDigest: string;
                    unchangedSharedObjects: Iterable<
                        readonly [
                            string
                            | Uint8Array<ArrayBufferLike>,
                            EnumInputShape<
                                {
                                    Cancelled: (...)
                                    | (...)
                                    | (...);
                                    MutateDeleted: (...) | (...) | (...);
                                    PerEpochConfig: (...) | (...) | (...) | (...);
                                    ReadDeleted: (...) | (...) | (...);
                                    ReadOnlyRoot: readonly [(...), (...)];
                                },
                            >,
                        ],
                        any,
                        any,
                    > & { length: number };
                };
            },
        >,
    >;
    TransactionExpiration: BcsType<
        EnumOutputShapeWithKeys<
            { Epoch: number; None: true },
            "None" | "Epoch",
        >,
        EnumInputShape<{ Epoch: string | number; None: null | boolean | object }>,
    >;
    TransactionKind: BcsType<
        EnumOutputShapeWithKeys<
            {
                ChangeEpoch: true;
                ConsensusCommitPrologue: true;
                Genesis: true;
                ProgrammableTransaction: {
                    commands: EnumOutputShapeWithKeys<
                        {
                            MakeMoveVec: {
                                elements: EnumOutputShapeWithKeys<(...), (...)>[];
                                type: null | string;
                            };
                            MergeCoins: {
                                destination: EnumOutputShapeWithKeys<
                                    { GasCoin: ...; Input: ...; NestedResult: ...; Result: ... },
                                    (...) | (...) | (...) | (...),
                                >;
                                sources: EnumOutputShapeWithKeys<(...), (...)>[];
                            };
                            MoveCall: {
                                arguments: EnumOutputShapeWithKeys<(...), (...)>[];
                                function: string;
                                module: string;
                                package: string;
                                typeArguments: string[];
                            };
                            Publish: { dependencies: string[]; modules: string[] };
                            SplitCoins: {
                                amounts: EnumOutputShapeWithKeys<(...), (...)>[];
                                coin: EnumOutputShapeWithKeys<
                                    { GasCoin: ...; Input: ...; NestedResult: ...; Result: ... },
                                    (...) | (...) | (...) | (...),
                                >;
                            };
                            TransferObjects: {
                                address: EnumOutputShapeWithKeys<
                                    { GasCoin: ...; Input: ...; NestedResult: ...; Result: ... },
                                    (...) | (...) | (...) | (...),
                                >;
                                objects: EnumOutputShapeWithKeys<(...), (...)>[];
                            };
                            Upgrade: {
                                dependencies: string[];
                                modules: string[];
                                package: string;
                                ticket: EnumOutputShapeWithKeys<
                                    { GasCoin: ...; Input: ...; NestedResult: ...; Result: ... },
                                    (...) | (...) | (...) | (...),
                                >;
                            };
                        },
                        | "MoveCall"
                        | "TransferObjects"
                        | "SplitCoins"
                        | "MergeCoins"
                        | "Publish"
                        | "MakeMoveVec"
                        | "Upgrade",
                    >[];
                    inputs: EnumOutputShapeWithKeys<
                        {
                            Object: EnumOutputShapeWithKeys<
                                {
                                    ImmOrOwnedObject: { digest: ...; objectId: ...; version: ... };
                                    Receiving: { digest: ...; objectId: ...; version: ... };
                                    SharedObject: {
                                        initialSharedVersion: ...;
                                        mutable: ...;
                                        objectId: ...;
                                    };
                                },
                                "ImmOrOwnedObject"
                                | "SharedObject"
                                | "Receiving",
                            >;
                            Pure: { bytes: string };
                        },
                        "Pure"
                        | "Object",
                    >[];
                };
            },
            | "ProgrammableTransaction"
            | "ChangeEpoch"
            | "Genesis"
            | "ConsensusCommitPrologue",
        >,
        EnumInputShape<
            {
                ChangeEpoch: null
                | boolean
                | object;
                ConsensusCommitPrologue: null | boolean | object;
                Genesis: null | boolean | object;
                ProgrammableTransaction: {
                    commands: Iterable<
                        EnumInputShape<
                            {
                                MakeMoveVec: { elements: (...) & (...); type: (...) | (...) };
                                MergeCoins: {
                                    destination: EnumInputShape<(...)>;
                                    sources: (...) & (...);
                                };
                                MoveCall: {
                                    arguments: (...) & (...);
                                    function: string;
                                    module: string;
                                    package: (...) | (...);
                                    typeArguments: (...) & (...);
                                };
                                Publish: { dependencies: (...) & (...); modules: (...) & (...) };
                                SplitCoins: { amounts: (...) & (...); coin: EnumInputShape<(...)> };
                                TransferObjects: {
                                    address: EnumInputShape<(...)>;
                                    objects: (...) & (...);
                                };
                                Upgrade: {
                                    dependencies: (...) & (...);
                                    modules: (...) & (...);
                                    package: (...) | (...);
                                    ticket: EnumInputShape<(...)>;
                                };
                            },
                        >,
                        any,
                        any,
                    > & { length: number };
                    inputs: Iterable<
                        EnumInputShape<
                            {
                                Object: EnumInputShape<
                                    { ImmOrOwnedObject: ...; Receiving: ...; SharedObject: ... },
                                >;
                                Pure: { bytes: (...) | (...) };
                            },
                        >,
                        any,
                        any,
                    > & { length: number };
                };
            },
        >,
    >;
    TypeTag: BcsType<string, string | TypeTag>;
    U128: BcsType<string, string | number | bigint>;
    U16: BcsType<number, number>;
    U256: BcsType<string, string | number | bigint>;
    U32: BcsType<number, number>;
    U64: BcsType<string, string | number | bigint>;
    U8: BcsType<number, number>;
    ULEB128: BcsType<number, number>;
    bool(options?: BcsTypeOptions<boolean, boolean>): BcsType<boolean, boolean>;
    bytes<T extends number>(
        size: T,
        options?: BcsTypeOptions<
            Uint8Array<ArrayBufferLike>,
            Iterable<number, any, any>,
        >,
    ): BcsType<Uint8Array<ArrayBufferLike>, Iterable<number, any, any>>;
    byteVector(
        options?: BcsTypeOptions<
            Uint8Array<ArrayBufferLike>,
            Iterable<number, any, any>,
        >,
    ): BcsType<Uint8Array<ArrayBufferLike>, Iterable<number, any, any>>;
    enum<T extends Record<string, null | BcsType<any, any>>>(
        name: string,
        values: T,
        options?: Omit<
            BcsTypeOptions<
                EnumOutputShape<
                    {
                        [K in string
                        | number
                        | symbol]: T[K] extends BcsType<U, any> ? U : true
                    },
                >,
                EnumInputShape<
                    {
                        [K in string
                        | number
                        | symbol]: T[K] extends BcsType<any, U> ? U : null | boolean | object
                    },
                >,
            >,
            "name",
        >,
    ): BcsType<
        EnumOutputShape<
            {
                [K in string
                | number
                | symbol]: T[K] extends BcsType<U, any> ? U : true
            },
        >,
        EnumInputShape<
            {
                [K_1 in string
                | number
                | symbol]: T[K_1] extends BcsType<any, U_1>
                    ? U_1
                    : null | boolean | object
            },
        >,
    >;
    fixedArray<T, Input>(
        size: number,
        type: BcsType<T, Input>,
        options?: BcsTypeOptions<
            T[],
            Iterable<Input, any, any> & { length: number },
        >,
    ): BcsType<T[], Iterable<Input, any, any> & { length: number }>;
    lazy<T extends BcsType<any, any>>(cb: () => T): T;
    map<K, V, InputK = K, InputV = V>(
        keyType: BcsType<K, InputK>,
        valueType: BcsType<V, InputV>,
    ): BcsType<Map<K, V>, Map<InputK, InputV>>;
    option<T, Input>(
        type: BcsType<T, Input>,
    ): BcsType<null | T, undefined | null | Input>;
    string(options?: BcsTypeOptions<string, string>): BcsType<string, string>;
    struct<T extends Record<string, BcsType<any, any>>>(
        name: string,
        fields: T,
        options?: Omit<
            BcsTypeOptions<
                {
                    [K in string
                    | number
                    | symbol]: T[K] extends BcsType<U, any> ? U : never
                },
                {
                    [K in string
                    | number
                    | symbol]: T[K] extends BcsType<any, U> ? U : never
                },
            >,
            "name",
        >,
    ): BcsType<
        {
            [K in string
            | number
            | symbol]: T[K] extends BcsType<U, any> ? U : never
        },
        {
            [K_1 in string
            | number
            | symbol]: T[K_1] extends BcsType<any, U_1> ? U_1 : never
        },
    >;
    tuple<const Types extends readonly BcsType<any, any>[]>(
        types: Types,
        options?: BcsTypeOptions<
            {
                -readonly [K in string
                | number
                | symbol]: Types[K<K>] extends BcsType<T, any> ? T : never
            },
            {
                [K in string
                | number
                | symbol]: Types[K<K>] extends BcsType<any, T> ? T : never
            },
        >,
    ): BcsType<
        {
            -readonly [K in string
            | number
            | symbol]: Types[K<K>] extends BcsType<T, any> ? T : never
        },
        {
            [K_1 in string
            | number
            | symbol]: Types[K_1<K_1>] extends BcsType<any, T_1> ? T_1 : never
        },
    >;
    u128(
        options?: BcsTypeOptions<string, string | number | bigint>,
    ): BcsType<string, string | number | bigint>;
    u16(options?: BcsTypeOptions<number, number>): BcsType<number, number>;
    u256(
        options?: BcsTypeOptions<string, string | number | bigint>,
    ): BcsType<string, string | number | bigint>;
    u32(options?: BcsTypeOptions<number, number>): BcsType<number, number>;
    u64(
        options?: BcsTypeOptions<string, string | number | bigint>,
    ): BcsType<string, string | number | bigint>;
    u8(options?: BcsTypeOptions<number, number>): BcsType<number, number>;
    uleb128(options?: BcsTypeOptions<number, number>): BcsType<number, number>;
    vector<T, Input>(
        type: BcsType<T, Input>,
        options?: BcsTypeOptions<
            T[],
            Iterable<Input, any, any> & { length: number },
        >,
    ): BcsType<T[], Iterable<Input, any, any> & { length: number }>;
} = ...