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<
        {
            FundsWithdrawal: BcsStruct<
                {
                    reservation: BcsEnum<
                        { MaxAmountU64: BcsType<string, string | number | bigint, "u64"> },
                        "Reservation",
                    >;
                    typeArg: BcsEnum<
                        { Balance: BcsType<string, string | TypeTag, string> },
                        "WithdrawalType",
                    >;
                    withdrawFrom: BcsEnum<{ Sender: null; Sponsor: null }, "WithdrawFrom">;
                },
                string,
            >;
            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<string | null, string | null, 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<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "bytes[64]",
            >;
            Passkey: BcsType<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "vector<u8>",
            >;
            Secp256k1: BcsType<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "bytes[64]",
            >;
            Secp256r1: BcsType<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "bytes[64]",
            >;
            ZkLogin: BcsType<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "vector<u8>",
            >;
        },
        "CompressedSignature",
    >;
    Data: BcsEnum<
        {
            Move: BcsStruct<
                {
                    contents: BcsType<
                        Uint8Array<ArrayBufferLike>,
                        Iterable<number, any, any>,
                        "vector<u8>",
                    >;
                    hasPublicTransfer: BcsType<boolean, boolean, "bool">;
                    type: BcsEnum<
                        {
                            AccumulatorBalanceWrapper: null;
                            Coin: BcsType<string, string | TypeTag, string>;
                            GasCoin: null;
                            Other: BcsStruct<
                                {
                                    address: BcsType<string, (...) | (...), "bytes[32]">;
                                    module: BcsType<string, string, "string">;
                                    name: BcsType<string, string, "string">;
                                    typeParams: BcsType<(...)[], (...) & (...), string>;
                                },
                                string,
                            >;
                            StakedSui: null;
                        },
                        "MoveObjectType",
                    >;
                    version: BcsType<string, string | number | bigint, "u64">;
                },
                string,
            >;
            Package: BcsStruct<
                {
                    id: BcsType<
                        string,
                        string
                        | Uint8Array<ArrayBufferLike>,
                        "bytes[32]",
                    >;
                    linkageTable: BcsType<
                        Map<string, { upgradedId: string; upgradedVersion: string }>,
                        Map<
                            string
                            | Uint8Array<ArrayBufferLike>,
                            {
                                upgradedId: string | Uint8Array<ArrayBufferLike>;
                                upgradedVersion: string | number | bigint;
                            },
                        >,
                        `Map<bytes[32], ${string}>`,
                    >;
                    moduleMap: BcsType<
                        Map<string, Uint8Array<ArrayBufferLike>>,
                        Map<string, Iterable<number, any, any>>,
                        "Map<string, vector<u8>>",
                    >;
                    typeOriginTable: BcsType<
                        { datatypeName: string; moduleName: string; package: string }[],
                        Iterable<
                            {
                                datatypeName: string;
                                moduleName: string;
                                package: string
                                | Uint8Array<(...)>;
                            },
                            any,
                            any,
                        > & { length: number },
                        string,
                    >;
                    version: BcsType<string, string | number | bigint, "u64">;
                },
                string,
            >;
        },
        "Data",
    >;
    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$1 extends BcsType<any, any, string>,
            V extends BcsType<any, any, string>,
        >(
            keyType: K$1,
            valueType: V,
        ): BcsType<
            Map<InferBcsType<K$1>, InferBcsType<V>>,
            Map<InferBcsInput<K$1>, InferBcsInput<V>>,
            `Map<${K$1["name"]}, ${V["name"]}>`,
        >;
        <K$1, V, InputK = K$1, InputV = V>(
            keyType: BcsType<K$1, InputK>,
            valueType: BcsType<V, InputV>,
        ): BcsType<Map<K$1, V>, Map<InputK, InputV>, `Map<${string}, ${string}>`>;
    };
    MoveObject: BcsStruct<
        {
            contents: BcsType<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "vector<u8>",
            >;
            hasPublicTransfer: BcsType<boolean, boolean, "bool">;
            type: BcsEnum<
                {
                    AccumulatorBalanceWrapper: null;
                    Coin: BcsType<string, string | TypeTag, string>;
                    GasCoin: null;
                    Other: 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,
                    >;
                    StakedSui: null;
                },
                "MoveObjectType",
            >;
            version: BcsType<string, string | number | bigint, "u64">;
        },
        string,
    >;
    MoveObjectType: BcsEnum<
        {
            AccumulatorBalanceWrapper: null;
            Coin: BcsType<string, string | TypeTag, string>;
            GasCoin: null;
            Other: 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,
            >;
            StakedSui: null;
        },
        "MoveObjectType",
    >;
    MovePackage: BcsStruct<
        {
            id: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
            linkageTable: BcsType<
                Map<string, { upgradedId: string; upgradedVersion: string }>,
                Map<
                    string
                    | Uint8Array<ArrayBufferLike>,
                    {
                        upgradedId: string | Uint8Array<ArrayBufferLike>;
                        upgradedVersion: string | number | bigint;
                    },
                >,
                `Map<bytes[32], ${string}>`,
            >;
            moduleMap: BcsType<
                Map<string, Uint8Array<ArrayBufferLike>>,
                Map<string, Iterable<number, any, any>>,
                "Map<string, vector<u8>>",
            >;
            typeOriginTable: BcsType<
                { datatypeName: string; moduleName: string; package: string }[],
                Iterable<
                    {
                        datatypeName: string;
                        moduleName: string;
                        package: string
                        | Uint8Array<ArrayBufferLike>;
                    },
                    any,
                    any,
                > & { length: number },
                string,
            >;
            version: BcsType<string, string | number | bigint, "u64">;
        },
        string,
    >;
    MultiSig: BcsStruct<
        {
            bitmap: BcsType<number, number, "u16">;
            multisig_pk: BcsStruct<
                {
                    pk_map: BcsType<
                        {
                            pubKey: EnumOutputShapeWithKeys<
                                {
                                    ED25519: Uint8Array<(...)>;
                                    Passkey: Uint8Array<(...)>;
                                    Secp256k1: Uint8Array<(...)>;
                                    Secp256r1: Uint8Array<(...)>;
                                    ZkLogin: Uint8Array<(...)>;
                                },
                                "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: Uint8Array<ArrayBufferLike>;
                        Passkey: Uint8Array<ArrayBufferLike>;
                        Secp256k1: Uint8Array<ArrayBufferLike>;
                        Secp256r1: Uint8Array<ArrayBufferLike>;
                        ZkLogin: Uint8Array<ArrayBufferLike>;
                    },
                    "ED25519"
                    | "Secp256k1"
                    | "Secp256r1"
                    | "ZkLogin"
                    | "Passkey",
                >[],
                Iterable<
                    EnumInputShape<
                        {
                            ED25519: Iterable<number, any, any>;
                            Passkey: Iterable<number, any, any>;
                            Secp256k1: Iterable<number, any, any>;
                            Secp256r1: Iterable<number, any, any>;
                            ZkLogin: Iterable<number, any, any>;
                        },
                    >,
                    any,
                    any,
                > & { length: number },
                string,
            >;
        },
        string,
    >;
    MultiSigPkMap: BcsStruct<
        {
            pubKey: BcsEnum<
                {
                    ED25519: BcsType<
                        Uint8Array<ArrayBufferLike>,
                        Iterable<number, any, any>,
                        "bytes[32]",
                    >;
                    Passkey: BcsType<
                        Uint8Array<ArrayBufferLike>,
                        Iterable<number, any, any>,
                        "bytes[33]",
                    >;
                    Secp256k1: BcsType<
                        Uint8Array<ArrayBufferLike>,
                        Iterable<number, any, any>,
                        "bytes[33]",
                    >;
                    Secp256r1: BcsType<
                        Uint8Array<ArrayBufferLike>,
                        Iterable<number, any, any>,
                        "bytes[33]",
                    >;
                    ZkLogin: BcsType<
                        Uint8Array<ArrayBufferLike>,
                        Iterable<number, any, any>,
                        "vector<u8>",
                    >;
                },
                "PublicKey",
            >;
            weight: BcsType<number, number, "u8">;
        },
        string,
    >;
    MultiSigPublicKey: BcsStruct<
        {
            pk_map: BcsType<
                {
                    pubKey: EnumOutputShapeWithKeys<
                        {
                            ED25519: Uint8Array<ArrayBufferLike>;
                            Passkey: Uint8Array<ArrayBufferLike>;
                            Secp256k1: Uint8Array<ArrayBufferLike>;
                            Secp256r1: Uint8Array<ArrayBufferLike>;
                            ZkLogin: Uint8Array<ArrayBufferLike>;
                        },
                        "ED25519"
                        | "Secp256k1"
                        | "Secp256r1"
                        | "ZkLogin"
                        | "Passkey",
                    >;
                    weight: number;
                }[],
                Iterable<
                    {
                        pubKey: EnumInputShape<
                            {
                                ED25519: Iterable<number, any, any>;
                                Passkey: Iterable<number, any, any>;
                                Secp256k1: Iterable<number, any, any>;
                                Secp256r1: Iterable<number, any, any>;
                                ZkLogin: Iterable<number, any, any>;
                            },
                        >;
                        weight: number;
                    },
                    any,
                    any,
                > & { length: number },
                string,
            >;
            threshold: BcsType<number, number, "u16">;
        },
        string,
    >;
    Object: BcsStruct<
        {
            data: BcsEnum<
                {
                    Move: BcsStruct<
                        {
                            contents: BcsType<
                                Uint8Array<ArrayBufferLike>,
                                Iterable<number, any, any>,
                                "vector<u8>",
                            >;
                            hasPublicTransfer: BcsType<boolean, boolean, "bool">;
                            type: BcsEnum<
                                {
                                    AccumulatorBalanceWrapper: null;
                                    Coin: BcsType<string, (...) | (...), string>;
                                    GasCoin: null;
                                    Other: BcsStruct<
                                        { address: ...; module: ...; name: ...; typeParams: ... },
                                        string,
                                    >;
                                    StakedSui: null;
                                },
                                "MoveObjectType",
                            >;
                            version: BcsType<string, string | number | bigint, "u64">;
                        },
                        string,
                    >;
                    Package: BcsStruct<
                        {
                            id: BcsType<
                                string,
                                string
                                | Uint8Array<ArrayBufferLike>,
                                "bytes[32]",
                            >;
                            linkageTable: BcsType<
                                Map<string, { upgradedId: string; upgradedVersion: string }>,
                                Map<
                                    string
                                    | Uint8Array<(...)>,
                                    {
                                        upgradedId: (...) | (...);
                                        upgradedVersion: (...) | (...) | (...);
                                    },
                                >,
                                `Map<bytes[32], ${string}>`,
                            >;
                            moduleMap: BcsType<
                                Map<string, Uint8Array<ArrayBufferLike>>,
                                Map<string, Iterable<number, any, any>>,
                                "Map<string, vector<u8>>",
                            >;
                            typeOriginTable: BcsType<
                                { datatypeName: string; moduleName: string; package: string }[],
                                Iterable<
                                    { datatypeName: ...; moduleName: ...; package: ... },
                                    any,
                                    any,
                                > & { length: number },
                                string,
                            >;
                            version: BcsType<string, string | number | bigint, "u64">;
                        },
                        string,
                    >;
                },
                "Data",
            >;
            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",
            >;
            previousTransaction: BcsType<string, string, "ObjectDigest">;
            storageRebate: BcsType<string, string | number | bigint, "u64">;
        },
        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<
            InferBcsType<T>
            | null,
            InferBcsInput<T> | null | undefined,
            `Option<${T["name"]}>`,
        >;
        <T, Input, Name extends string = string>(
            type: BcsType<T, Input, Name>,
        ): BcsType<T | null, Input | null | undefined>;
    };
    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<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "vector<u8>",
            >;
            clientDataJson: BcsType<string, string, "string">;
            userSignature: BcsType<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "vector<u8>",
            >;
        },
        string,
    >;
    ProgrammableMoveCall: BcsStruct<
        {
            arguments: BcsType<
                EnumOutputShapeWithKeys<
                    {
                        GasCoin: true;
                        Input: number;
                        NestedResult: [number, number];
                        Result: number;
                    },
                    "GasCoin"
                    | "Input"
                    | "Result"
                    | "NestedResult",
                >[],
                Iterable<
                    EnumInputShape<
                        {
                            GasCoin: boolean
                            | object
                            | null;
                            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: string | null;
                        };
                        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: string | null;
                            };
                            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<
                    {
                        FundsWithdrawal: {
                            reservation: { $kind: "MaxAmountU64"; MaxAmountU64: string };
                            typeArg: { $kind: "Balance"; Balance: string };
                            withdrawFrom: EnumOutputShapeWithKeys<
                                { Sender: true; Sponsor: true },
                                "Sender" | "Sponsor",
                            >;
                        };
                        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 };
                    },
                    "FundsWithdrawal"
                    | "Pure"
                    | "Object",
                >[],
                Iterable<
                    EnumInputShape<
                        {
                            FundsWithdrawal: {
                                reservation: { MaxAmountU64: (...)
                                | (...)
                                | (...) };
                                typeArg: { Balance: (...) | (...) };
                                withdrawFrom: EnumInputShape<{ Sender: ...; Sponsor: ... }>;
                            };
                            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<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "bytes[32]",
            >;
            Passkey: BcsType<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "bytes[33]",
            >;
            Secp256k1: BcsType<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "bytes[33]",
            >;
            Secp256r1: BcsType<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "bytes[33]",
            >;
            ZkLogin: BcsType<
                Uint8Array<ArrayBufferLike>,
                Iterable<number, any, any>,
                "vector<u8>",
            >;
        },
        "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;
                                ValidDuring: {
                                    chain: string;
                                    maxEpoch: (...)
                                    | (...);
                                    maxTimestamp: (...) | (...);
                                    minEpoch: (...) | (...);
                                    minTimestamp: (...) | (...);
                                    nonce: number;
                                };
                            },
                            "None"
                            | "ValidDuring"
                            | "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: boolean
                        | object
                        | null };
                        scope: EnumInputShape<
                            {
                                CheckpointSummary: boolean
                                | object
                                | null;
                                PersonalMessage: boolean | object | null;
                                TransactionData: boolean | object | null;
                                TransactionEffects: boolean | object | null;
                            },
                        >;
                        version: { V0: boolean
                        | object
                        | null };
                    };
                    value: {
                        V1: {
                            expiration: EnumInputShape<
                                {
                                    Epoch: (...)
                                    | (...);
                                    None: (...) | (...) | (...) | (...);
                                    ValidDuring: {
                                        chain: ...;
                                        maxEpoch: ...;
                                        maxTimestamp: ...;
                                        minEpoch: ...;
                                        minTimestamp: ...;
                                        nonce: ...;
                                    };
                                },
                            >;
                            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: ...; ValidDuring: ... },
                                        "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;
                            ValidDuring: BcsStruct<
                                {
                                    chain: BcsType<string, string, "ObjectDigest">;
                                    maxEpoch: BcsType<
                                        (...)
                                        | (...),
                                        (...) | (...) | (...) | (...) | (...),
                                        "Option<u64>",
                                    >;
                                    maxTimestamp: BcsType<
                                        (...)
                                        | (...),
                                        (...) | (...) | (...) | (...) | (...),
                                        "Option<u64>",
                                    >;
                                    minEpoch: BcsType<
                                        (...)
                                        | (...),
                                        (...) | (...) | (...) | (...) | (...),
                                        "Option<u64>",
                                    >;
                                    minTimestamp: BcsType<
                                        (...)
                                        | (...),
                                        (...) | (...) | (...) | (...) | (...),
                                        "Option<u64>",
                                    >;
                                    nonce: BcsType<number, number, "u32">;
                                },
                                string,
                            >;
                        },
                        "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;
                    ValidDuring: BcsStruct<
                        {
                            chain: BcsType<string, string, "ObjectDigest">;
                            maxEpoch: BcsType<
                                string
                                | null,
                                string | number | bigint | null | undefined,
                                "Option<u64>",
                            >;
                            maxTimestamp: BcsType<
                                string
                                | null,
                                string | number | bigint | null | undefined,
                                "Option<u64>",
                            >;
                            minEpoch: BcsType<
                                string
                                | null,
                                string | number | bigint | null | undefined,
                                "Option<u64>",
                            >;
                            minTimestamp: BcsType<
                                string
                                | null,
                                string | number | bigint | null | undefined,
                                "Option<u64>",
                            >;
                            nonce: BcsType<number, number, "u32">;
                        },
                        string,
                    >;
                },
                "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<
                                    { FundsWithdrawal: ...; 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<
                        string
                        | null,
                        string | null | undefined,
                        "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<
                        {
                            Failure: BcsStruct<
                                {
                                    command: BcsType<
                                        (...)
                                        | (...),
                                        (...) | (...) | (...) | (...) | (...),
                                        "Option<u64>",
                                    >;
                                    error: BcsEnum<
                                        {
                                            AddressDeniedForCoin: ...;
                                            ArityMismatch: ...;
                                            CertificateDenied: ...;
                                            CircularObjectOwnership: ...;
                                            CoinBalanceOverflow: ...;
                                            CoinTypeGlobalPause: ...;
                                            CommandArgumentError: ...;
                                            EffectsTooLarge: ...;
                                            ExecutionCancelledDueToRandomnessUnavailable: ...;
                                            ExecutionCancelledDueToSharedObjectCongestion: ...;
                                            FeatureNotYetSupported: ...;
                                            FunctionNotFound: ...;
                                            InputObjectDeleted: ...;
                                            InsufficientBalanceForWithdraw: ...;
                                            InsufficientCoinBalance: ...;
                                            InsufficientGas: ...;
                                            InvalidGasObject: ...;
                                            InvalidLinkage: ...;
                                            InvalidPublicFunctionReturnType: ...;
                                            InvalidTransferObject: ...;
                                            InvariantViolation: ...;
                                            MoveAbort: ...;
                                            MoveObjectTooBig: ...;
                                            MovePackageTooBig: ...;
                                            MovePrimitiveRuntimeError: ...;
                                            MoveRawValueTooBig: ...;
                                            MoveVectorElemTooBig: ...;
                                            NonEntryFunctionInvoked: ...;
                                            NonExclusiveWriteInputObjectModified: ...;
                                            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<
                        string
                        | null,
                        string | null | undefined,
                        "Option<ObjectDigest>",
                    >;
                    changedObjects: BcsType<
                        [
                            string,
                            {
                                idOperation: EnumOutputShapeWithKeys<
                                    { Created: ...; Deleted: ...; None: ... },
                                    (...) | (...) | (...),
                                >;
                                inputState: EnumOutputShapeWithKeys<
                                    { Exist: ...; NotExist: ... },
                                    (...) | (...),
                                >;
                                outputState: EnumOutputShapeWithKeys<
                                    {
                                        AccumulatorWriteV1: ...;
                                        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<
                        string
                        | null,
                        string | null | undefined,
                        "Option<ObjectDigest>",
                    >;
                    executedEpoch: BcsType<string, string | number | bigint, "u64">;
                    gasObjectIndex: BcsType<
                        number
                        | null,
                        number | null | undefined,
                        "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<
                        {
                            Failure: BcsStruct<
                                {
                                    command: BcsType<
                                        (...)
                                        | (...),
                                        (...) | (...) | (...) | (...) | (...),
                                        "Option<u64>",
                                    >;
                                    error: BcsEnum<
                                        {
                                            AddressDeniedForCoin: ...;
                                            ArityMismatch: ...;
                                            CertificateDenied: ...;
                                            CircularObjectOwnership: ...;
                                            CoinBalanceOverflow: ...;
                                            CoinTypeGlobalPause: ...;
                                            CommandArgumentError: ...;
                                            EffectsTooLarge: ...;
                                            ExecutionCancelledDueToRandomnessUnavailable: ...;
                                            ExecutionCancelledDueToSharedObjectCongestion: ...;
                                            FeatureNotYetSupported: ...;
                                            FunctionNotFound: ...;
                                            InputObjectDeleted: ...;
                                            InsufficientBalanceForWithdraw: ...;
                                            InsufficientCoinBalance: ...;
                                            InsufficientGas: ...;
                                            InvalidGasObject: ...;
                                            InvalidLinkage: ...;
                                            InvalidPublicFunctionReturnType: ...;
                                            InvalidTransferObject: ...;
                                            InvariantViolation: ...;
                                            MoveAbort: ...;
                                            MoveObjectTooBig: ...;
                                            MovePackageTooBig: ...;
                                            MovePrimitiveRuntimeError: ...;
                                            MoveRawValueTooBig: ...;
                                            MoveVectorElemTooBig: ...;
                                            NonEntryFunctionInvoked: ...;
                                            NonExclusiveWriteInputObjectModified: ...;
                                            PackageUpgradeError: ...;
                                            PublishErrorNonZeroAddress: ...;
                                            PublishUpgradeDependencyDowngrade: ...;
                                            PublishUpgradeMissingDependency: ...;
                                            SharedObjectOperationNotAllowed: ...;
                                            SuiMoveVerificationError: ...;
                                            SuiMoveVerificationTimedout: ...;
                                            TypeArgumentError: ...;
                                            TypeArityMismatch: ...;
                                            UnusedValueWithoutDrop: ...;
                                            VMInvariantViolation: ...;
                                            VMVerificationOrDeserializationError: ...;
                                            WrittenObjectsTooLarge: ...;
                                        },
                                        "ExecutionFailureStatus",
                                    >;
                                },
                                string,
                            >;
                            Success: null;
                        },
                        "ExecutionStatus",
                    >;
                    transactionDigest: BcsType<string, string, "ObjectDigest">;
                    unchangedConsensusObjects: BcsType<
                        [
                            string,
                            EnumOutputShapeWithKeys<
                                {
                                    Cancelled: string;
                                    MutateConsensusStreamEnded: string;
                                    PerEpochConfig: true;
                                    ReadConsensusStreamEnded: string;
                                    ReadOnlyRoot: [(...), (...)];
                                },
                                | "ReadOnlyRoot"
                                | "MutateConsensusStreamEnded"
                                | "ReadConsensusStreamEnded"
                                | "Cancelled"
                                | "PerEpochConfig",
                            >,
                        ][],
                        Iterable<
                            readonly [
                                string
                                | Uint8Array<(...)>,
                                EnumInputShape<
                                    {
                                        Cancelled: ...;
                                        MutateConsensusStreamEnded: ...;
                                        PerEpochConfig: ...;
                                        ReadConsensusStreamEnded: ...;
                                        ReadOnlyRoot: ...;
                                    },
                                >,
                            ],
                            any,
                            any,
                        > & { length: number },
                        string,
                    >;
                },
                string,
            >;
        },
        "TransactionEffects",
    >;
    TransactionExpiration: BcsEnum<
        {
            Epoch: BcsType<number, string | number, "u64">;
            None: null;
            ValidDuring: BcsStruct<
                {
                    chain: BcsType<string, string, "ObjectDigest">;
                    maxEpoch: BcsType<
                        string
                        | null,
                        string | number | bigint | null | undefined,
                        "Option<u64>",
                    >;
                    maxTimestamp: BcsType<
                        string
                        | null,
                        string | number | bigint | null | undefined,
                        "Option<u64>",
                    >;
                    minEpoch: BcsType<
                        string
                        | null,
                        string | number | bigint | null | undefined,
                        "Option<u64>",
                    >;
                    minTimestamp: BcsType<
                        string
                        | null,
                        string | number | bigint | null | undefined,
                        "Option<u64>",
                    >;
                    nonce: BcsType<number, number, "u32">;
                },
                string,
            >;
        },
        "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<
                            {
                                FundsWithdrawal: {
                                    reservation: { $kind: ...; MaxAmountU64: ... };
                                    typeArg: { $kind: ...; Balance: ... };
                                    withdrawFrom: EnumOutputShapeWithKeys<(...), (...)>;
                                };
                                Object: EnumOutputShapeWithKeys<
                                    { ImmOrOwnedObject: ...; Receiving: ...; SharedObject: ... },
                                    (...) | (...) | (...),
                                >;
                                Pure: { bytes: string };
                            },
                            "FundsWithdrawal"
                            | "Pure"
                            | "Object",
                        >[],
                        Iterable<
                            EnumInputShape<
                                {
                                    FundsWithdrawal: {
                                        reservation: ...;
                                        typeArg: ...;
                                        withdrawFrom: ...;
                                    };
                                    Object: EnumInputShape<(...)>;
                                    Pure: { bytes: ... };
                                },
                            >,
                            any,
                            any,
                        > & { length: number },
                        string,
                    >;
                },
                string,
            >;
        },
        "TransactionKind",
    >;
    TypeOrigin: BcsStruct<
        {
            datatypeName: BcsType<string, string, "string">;
            moduleName: BcsType<string, string, "string">;
            package: BcsType<
                string,
                string
                | Uint8Array<ArrayBufferLike>,
                "bytes[32]",
            >;
        },
        string,
    >;
    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, "uleb128">;
    UpgradeInfo: BcsStruct<
        {
            upgradedId: BcsType<
                string,
                string
                | Uint8Array<ArrayBufferLike>,
                "bytes[32]",
            >;
            upgradedVersion: BcsType<string, string | number | bigint, "u64">;
        },
        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, BcsType<any, any, string> | null>,
        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
                            : boolean | object | null
                    },
                >,
                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] extends BcsType<any, any, T_1> ? T_1 : never
            },
            ", ",
        >})`,
    >(
        fields: T,
        options?: BcsTypeOptions<
            {
                -readonly [K_1 in string
                | number
                | symbol]: T[K_1] extends BcsType<T_1, any, string> ? T_1 : never
            },
            {
                [K_1 in string
                | number
                | symbol]: T[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, "uleb128">;
} = ...