Variable bcsConst

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