Documentation

    Variable bcsConst

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

    Type declaration

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

        Parameters

        Returns BcsType<boolean, boolean>

        bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]
        
    • bytes: function
      • Creates a BcsType representing a fixed length byte array

        Type Parameters

        • T extends number

        Parameters

        • size: T

          The number of bytes this types represents

        • Optionaloptions: BcsTypeOptions<Uint8Array<ArrayBufferLike>, Iterable<number, any, any>>

        Returns BcsType<Uint8Array<ArrayBufferLike>, Iterable<number, any, any>>

        bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]
        
    • byteVector: function
      • Creates a BcsType representing a variable length byte array

        Parameters

        • Optionaloptions: BcsTypeOptions<Uint8Array<ArrayBufferLike>, Iterable<number, any, any>>

        Returns BcsType<Uint8Array<ArrayBufferLike>, Iterable<number, any, any>>

        bcs.byteVector().serialize([1, 2, 3]).toBytes() // Uint8Array [3, 1, 2, 3]
        
    • enum: function
      • Creates a BcsType representing an enum of a given set of options

        Type Parameters

        • T extends Record<string, null | BcsType<any, any>>

        Parameters

        • name: string

          The name of the enum

        • values: T

          The values of the enum. The order of the values affects how data is serialized and deserialized. null can be used to represent a variant with no data.

        • Optionaloptions: Omit<
              BcsTypeOptions<
                  EnumOutputShape<
                      {
                          [K in string
                          | number
                          | symbol]: T[K] extends BcsType<U, any> ? U : true
                      },
                  >,
                  EnumInputShape<
                      {
                          [K in string
                          | number
                          | symbol]: T[K] extends BcsType<any, U> ? U : null | boolean | object
                      },
                  >,
              >,
              "name",
          >

        Returns BcsType<
            EnumOutputShape<
                {
                    [K in string
                    | number
                    | symbol]: T[K] extends BcsType<U, any> ? U : true
                },
            >,
            EnumInputShape<
                {
                    [K_1 in string
                    | number
                    | symbol]: T[K_1] extends BcsType<any, U_1>
                        ? U_1
                        : null | boolean | object
                },
            >,
        >

        const enum = bcs.enum('MyEnum', {
        A: bcs.u8(),
        B: bcs.string(),
        C: null,
        })
        enum.serialize({ A: 1 }).toBytes() // Uint8Array [ 0, 1 ]
        enum.serialize({ B: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
        enum.serialize({ C: true }).toBytes() // Uint8Array [ 2 ]
    • fixedArray: function
      • Creates a BcsType that represents a fixed length array of a given type

        Type Parameters

        • T
        • Input

        Parameters

        • size: number

          The number of elements in the array

        • type: BcsType<T, Input>

          The BcsType of each element in the array

        • Optionaloptions: BcsTypeOptions<T[], Iterable<Input, any, any> & { length: number }>

        Returns BcsType<T[], Iterable<Input, any, any> & { length: number }>

        bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]
        
    • lazy: function
      • Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.

        Type Parameters

        Parameters

        • cb: () => T

          A callback that returns the BcsType

        Returns T

    • map: function
      • Creates a BcsType representing a map of a given key and value type

        Type Parameters

        • K
        • V
        • InputK = K
        • InputV = V

        Parameters

        Returns BcsType<Map<K, V>, Map<InputK, InputV>>

        const map = bcs.map(bcs.u8(), bcs.string())
        map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]
    • option: function
      • Creates a BcsType representing an optional value

        Type Parameters

        • T
        • Input

        Parameters

        Returns BcsType<null | T, undefined | null | Input>

        bcs.option(bcs.u8()).serialize(null).toBytes() // Uint8Array [ 0 ]
        bcs.option(bcs.u8()).serialize(1).toBytes() // Uint8Array [ 1, 1 ]
    • string: function
      • Creates a BcsType that can ser/de string values. Strings will be UTF-8 encoded

        Parameters

        Returns BcsType<string, string>

        bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]
        
    • struct: function
      • Creates a BcsType representing a struct of a given set of fields

        Type Parameters

        • T extends Record<string, BcsType<any, any>>

        Parameters

        • name: string

          The name of the struct

        • fields: T

          The fields of the struct. The order of the fields affects how data is serialized and deserialized

        • Optionaloptions: Omit<
              BcsTypeOptions<
                  {
                      [K in string
                      | number
                      | symbol]: T[K] extends BcsType<U, any> ? U : never
                  },
                  {
                      [K in string
                      | number
                      | symbol]: T[K] extends BcsType<any, U> ? U : never
                  },
              >,
              "name",
          >

        Returns BcsType<
            {
                [K in string
                | number
                | symbol]: T[K] extends BcsType<U, any> ? U : never
            },
            {
                [K_1 in string
                | number
                | symbol]: T[K_1] extends BcsType<any, U_1> ? U_1 : never
            },
        >

        const struct = bcs.struct('MyStruct', {
        a: bcs.u8(),
        b: bcs.string(),
        })
        struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
    • tuple: function
      • Creates a BcsType representing a tuple of a given set of types

        Type Parameters

        • const Types extends readonly BcsType<any, any>[]

        Parameters

        • types: Types

          The BcsTypes for each element in the tuple

        • Optionaloptions: BcsTypeOptions<
              {
                  -readonly [K in string
                  | number
                  | symbol]: Types[K<K>] extends BcsType<T, any> ? T : never
              },
              {
                  [K in string
                  | number
                  | symbol]: Types[K<K>] extends BcsType<any, T> ? T : never
              },
          >

        Returns BcsType<
            {
                -readonly [K in string
                | number
                | symbol]: Types[K<K>] extends BcsType<T, any> ? T : never
            },
            {
                [K_1 in string
                | number
                | symbol]: Types[K_1<K_1>] extends BcsType<any, T_1> ? T_1 : never
            },
        >

        const tuple = bcs.tuple([bcs.u8(), bcs.string(), bcs.bool()])
        tuple.serialize([1, 'a', true]).toBytes() // Uint8Array [ 1, 1, 97, 1 ]
    • u128: function
      • Creates a BcsType that can be used to read and write a 128-bit unsigned integer.

        Parameters

        Returns BcsType<string, string | number | bigint>

        bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
        
    • u16: function
      • Creates a BcsType that can be used to read and write a 16-bit unsigned integer.

        Parameters

        Returns BcsType<number, number>

        bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]
        
    • u256: function
      • Creates a BcsType that can be used to read and write a 256-bit unsigned integer.

        Parameters

        Returns BcsType<string, string | number | bigint>

        bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
        
    • u32: function
      • Creates a BcsType that can be used to read and write a 32-bit unsigned integer.

        Parameters

        Returns BcsType<number, number>

        bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]
        
    • u64: function
      • Creates a BcsType that can be used to read and write a 64-bit unsigned integer.

        Parameters

        Returns BcsType<string, string | number | bigint>

        bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]
        
    • u8: function
      • Creates a BcsType that can be used to read and write an 8-bit unsigned integer.

        Parameters

        Returns BcsType<number, number>

        bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]
        
    • uleb128: function
      • Creates a BcsType that can be used to read and write unsigned LEB encoded integers

        Parameters

        Returns BcsType<number, number>

        
        
    • vector: function
      • Creates a BcsType representing a variable length vector of a given type

        Type Parameters

        • T
        • Input

        Parameters

        Returns BcsType<T[], Iterable<Input, any, any> & { length: number }>

        bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]
        
    MMNEPVFCICPMFPCPTTAAATR