Documentation
    Preparing search index...

    Variable bcsConst

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

    Type declaration

    • Address: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">
    • AppId: BcsEnum<{ Sui: null }, "AppId">
    • Argument: BcsEnum<
          {
              GasCoin: null;
              Input: BcsType<number, number, "u16">;
              NestedResult: BcsTuple<
                  readonly [
                      BcsType<number, number, "u16">,
                      BcsType<number, number, "u16">,
                  ],
                  string,
              >;
              Result: BcsType<number, number, "u16">;
          },
          "Argument",
      >
    • Bool: BcsType<boolean, boolean, "bool">
    • CallArg: BcsEnum<
          {
              Object: BcsEnum<
                  {
                      ImmOrOwnedObject: BcsStruct<
                          {
                              digest: BcsType<string, string, "ObjectDigest">;
                              objectId: BcsType<
                                  string,
                                  string
                                  | Uint8Array<ArrayBufferLike>,
                                  "bytes[32]",
                              >;
                              version: BcsType<string, string | number | bigint, "u64">;
                          },
                          string,
                      >;
                      Receiving: BcsStruct<
                          {
                              digest: BcsType<string, string, "ObjectDigest">;
                              objectId: BcsType<
                                  string,
                                  string
                                  | Uint8Array<ArrayBufferLike>,
                                  "bytes[32]",
                              >;
                              version: BcsType<string, string | number | bigint, "u64">;
                          },
                          string,
                      >;
                      SharedObject: BcsStruct<
                          {
                              initialSharedVersion: BcsType<
                                  string,
                                  string
                                  | number
                                  | bigint,
                                  "u64",
                              >;
                              mutable: BcsType<boolean, boolean, "bool">;
                              objectId: BcsType<
                                  string,
                                  string
                                  | Uint8Array<ArrayBufferLike>,
                                  "bytes[32]",
                              >;
                          },
                          string,
                      >;
                  },
                  "ObjectArg",
              >;
              Pure: BcsStruct<
                  {
                      bytes: BcsType<string, string | Uint8Array<ArrayBufferLike>, string>;
                  },
                  string,
              >;
          },
          "CallArg",
      >
    • Command: BcsEnum<
          {
              MakeMoveVec: BcsStruct<
                  {
                      elements: BcsType<
                          EnumOutputShapeWithKeys<
                              {
                                  GasCoin: true;
                                  Input: number;
                                  NestedResult: [number, number];
                                  Result: number;
                              },
                              "GasCoin"
                              | "Input"
                              | "Result"
                              | "NestedResult",
                          >[],
                          Iterable<
                              EnumInputShape<
                                  {
                                      GasCoin: (...)
                                      | (...)
                                      | (...)
                                      | (...);
                                      Input: number;
                                      NestedResult: readonly [(...), (...)];
                                      Result: number;
                                  },
                              >,
                              any,
                              any,
                          > & { length: number },
                          string,
                      >;
                      type: BcsType<null | string, null | string, string>;
                  },
                  string,
              >;
              MergeCoins: BcsStruct<
                  {
                      destination: BcsEnum<
                          {
                              GasCoin: null;
                              Input: BcsType<number, number, "u16">;
                              NestedResult: BcsTuple<
                                  readonly [
                                      BcsType<number, number, "u16">,
                                      BcsType<number, number, "u16">,
                                  ],
                                  string,
                              >;
                              Result: BcsType<number, number, "u16">;
                          },
                          "Argument",
                      >;
                      sources: BcsType<
                          EnumOutputShapeWithKeys<
                              {
                                  GasCoin: true;
                                  Input: number;
                                  NestedResult: [number, number];
                                  Result: number;
                              },
                              "GasCoin"
                              | "Input"
                              | "Result"
                              | "NestedResult",
                          >[],
                          Iterable<
                              EnumInputShape<
                                  {
                                      GasCoin: (...)
                                      | (...)
                                      | (...)
                                      | (...);
                                      Input: number;
                                      NestedResult: readonly [(...), (...)];
                                      Result: number;
                                  },
                              >,
                              any,
                              any,
                          > & { length: number },
                          string,
                      >;
                  },
                  string,
              >;
              MoveCall: BcsStruct<
                  {
                      arguments: BcsType<
                          EnumOutputShapeWithKeys<
                              {
                                  GasCoin: true;
                                  Input: number;
                                  NestedResult: [number, number];
                                  Result: number;
                              },
                              "GasCoin"
                              | "Input"
                              | "Result"
                              | "NestedResult",
                          >[],
                          Iterable<
                              EnumInputShape<
                                  {
                                      GasCoin: (...)
                                      | (...)
                                      | (...)
                                      | (...);
                                      Input: number;
                                      NestedResult: readonly [(...), (...)];
                                      Result: number;
                                  },
                              >,
                              any,
                              any,
                          > & { length: number },
                          string,
                      >;
                      function: BcsType<string, string, "string">;
                      module: BcsType<string, string, "string">;
                      package: BcsType<
                          string,
                          string
                          | Uint8Array<ArrayBufferLike>,
                          "bytes[32]",
                      >;
                      typeArguments: BcsType<
                          string[],
                          Iterable<string | TypeTag, any, any> & { length: number },
                          string,
                      >;
                  },
                  string,
              >;
              Publish: BcsStruct<
                  {
                      dependencies: BcsType<
                          string[],
                          Iterable<string | Uint8Array<ArrayBufferLike>, any, any> & {
                              length: number;
                          },
                          string,
                      >;
                      modules: BcsType<
                          string[],
                          Iterable<string | Uint8Array<ArrayBufferLike>, any, any> & {
                              length: number;
                          },
                          string,
                      >;
                  },
                  string,
              >;
              SplitCoins: BcsStruct<
                  {
                      amounts: BcsType<
                          EnumOutputShapeWithKeys<
                              {
                                  GasCoin: true;
                                  Input: number;
                                  NestedResult: [number, number];
                                  Result: number;
                              },
                              "GasCoin"
                              | "Input"
                              | "Result"
                              | "NestedResult",
                          >[],
                          Iterable<
                              EnumInputShape<
                                  {
                                      GasCoin: (...)
                                      | (...)
                                      | (...)
                                      | (...);
                                      Input: number;
                                      NestedResult: readonly [(...), (...)];
                                      Result: number;
                                  },
                              >,
                              any,
                              any,
                          > & { length: number },
                          string,
                      >;
                      coin: BcsEnum<
                          {
                              GasCoin: null;
                              Input: BcsType<number, number, "u16">;
                              NestedResult: BcsTuple<
                                  readonly [
                                      BcsType<number, number, "u16">,
                                      BcsType<number, number, "u16">,
                                  ],
                                  string,
                              >;
                              Result: BcsType<number, number, "u16">;
                          },
                          "Argument",
                      >;
                  },
                  string,
              >;
              TransferObjects: BcsStruct<
                  {
                      address: BcsEnum<
                          {
                              GasCoin: null;
                              Input: BcsType<number, number, "u16">;
                              NestedResult: BcsTuple<
                                  readonly [
                                      BcsType<number, number, "u16">,
                                      BcsType<number, number, "u16">,
                                  ],
                                  string,
                              >;
                              Result: BcsType<number, number, "u16">;
                          },
                          "Argument",
                      >;
                      objects: BcsType<
                          EnumOutputShapeWithKeys<
                              {
                                  GasCoin: true;
                                  Input: number;
                                  NestedResult: [number, number];
                                  Result: number;
                              },
                              "GasCoin"
                              | "Input"
                              | "Result"
                              | "NestedResult",
                          >[],
                          Iterable<
                              EnumInputShape<
                                  {
                                      GasCoin: (...)
                                      | (...)
                                      | (...)
                                      | (...);
                                      Input: number;
                                      NestedResult: readonly [(...), (...)];
                                      Result: number;
                                  },
                              >,
                              any,
                              any,
                          > & { length: number },
                          string,
                      >;
                  },
                  string,
              >;
              Upgrade: BcsStruct<
                  {
                      dependencies: BcsType<
                          string[],
                          Iterable<string | Uint8Array<ArrayBufferLike>, any, any> & {
                              length: number;
                          },
                          string,
                      >;
                      modules: BcsType<
                          string[],
                          Iterable<string | Uint8Array<ArrayBufferLike>, any, any> & {
                              length: number;
                          },
                          string,
                      >;
                      package: BcsType<
                          string,
                          string
                          | Uint8Array<ArrayBufferLike>,
                          "bytes[32]",
                      >;
                      ticket: BcsEnum<
                          {
                              GasCoin: null;
                              Input: BcsType<number, number, "u16">;
                              NestedResult: BcsTuple<
                                  readonly [
                                      BcsType<number, number, "u16">,
                                      BcsType<number, number, "u16">,
                                  ],
                                  string,
                              >;
                              Result: BcsType<number, number, "u16">;
                          },
                          "Argument",
                      >;
                  },
                  string,
              >;
          },
          "Command",
      >
    • CompressedSignature: BcsEnum<
          {
              ED25519: BcsType<
                  number[],
                  Iterable<number, any, any> & { length: number },
                  string,
              >;
              Passkey: BcsType<
                  number[],
                  Iterable<number, any, any> & { length: number },
                  string,
              >;
              Secp256k1: BcsType<
                  number[],
                  Iterable<number, any, any> & { length: number },
                  string,
              >;
              Secp256r1: BcsType<
                  number[],
                  Iterable<number, any, any> & { length: number },
                  string,
              >;
              ZkLogin: BcsType<
                  number[],
                  Iterable<number, any, any> & { length: number },
                  string,
              >;
          },
          "CompressedSignature",
      >
    • fixedArray: {
          <T extends BcsType<any, any, string>, Name extends string = string>(
              size: number,
              type: T,
              options?: BcsTypeOptions<
                  InferBcsType<T>[],
                  Iterable<InferBcsInput<T>, any, any> & { length: number },
                  Name,
              >,
          ): BcsType<
              InferBcsType<T>[],
              Iterable<InferBcsInput<T>, any, any> & { length: number },
              Name,
          >;
          <T, Input, Name extends string = string>(
              size: number,
              type: BcsType<T, Input>,
              options?: BcsTypeOptions<
                  T[],
                  Iterable<Input, any, any> & { length: number },
                  Name,
              >,
          ): BcsType<T[], Iterable<Input, any, any> & { length: number }, Name>;
      }

      Creates a BcsType that represents a fixed length array of a given type

      The number of elements in the array

      The BcsType of each element in the array

      bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]
      
    • GasData: BcsStruct<
          {
              budget: BcsType<string, string | number | bigint, "u64">;
              owner: BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
              payment: BcsType<
                  { digest: string; objectId: string; version: string }[],
                  Iterable<
                      {
                          digest: string;
                          objectId: string
                          | Uint8Array<ArrayBufferLike>;
                          version: string | number | bigint;
                      },
                      any,
                      any,
                  > & { length: number },
                  string,
              >;
              price: BcsType<string, string | number | bigint, "u64">;
          },
          string,
      >
    • Intent: BcsStruct<
          {
              appId: BcsEnum<{ Sui: null }, "AppId">;
              scope: BcsEnum<
                  {
                      CheckpointSummary: null;
                      PersonalMessage: null;
                      TransactionData: null;
                      TransactionEffects: null;
                  },
                  "IntentScope",
              >;
              version: BcsEnum<{ V0: null }, "IntentVersion">;
          },
          string,
      >
    • IntentMessage: <T extends BcsType<any, any, string>>(
          T: T,
      ) => BcsStruct<
          {
              intent: BcsStruct<
                  {
                      appId: BcsEnum<{ Sui: null }, "AppId">;
                      scope: BcsEnum<
                          {
                              CheckpointSummary: null;
                              PersonalMessage: null;
                              TransactionData: null;
                              TransactionEffects: null;
                          },
                          "IntentScope",
                      >;
                      version: BcsEnum<{ V0: null }, "IntentVersion">;
                  },
                  string,
              >;
              value: T;
          },
          string,
      >
    • IntentScope: BcsEnum<
          {
              CheckpointSummary: null;
              PersonalMessage: null;
              TransactionData: null;
              TransactionEffects: null;
          },
          "IntentScope",
      >
    • IntentVersion: BcsEnum<{ V0: null }, "IntentVersion">
    • map: {
          <
              K extends BcsType<any, any, string>,
              V extends BcsType<any, any, string>,
          >(
              keyType: K,
              valueType: V,
          ): BcsType<
              Map<InferBcsType<K>, InferBcsType<V>>,
              Map<InferBcsInput<K>, InferBcsInput<V>>,
              `Map<${K["name"]}, ${V["name"]}>`,
          >;
          <K, V, InputK = K, InputV = V>(
              keyType: BcsType<K, InputK>,
              valueType: BcsType<V, InputV>,
          ): BcsType<Map<K, V>, Map<InputK, InputV>, `Map<${string}, ${string}>`>;
      }

      Creates a BcsType representing a map of a given key and value type

      The BcsType of the key

      The BcsType of the value

      const map = bcs.map(bcs.u8(), bcs.string())
      map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]
    • MultiSig: BcsStruct<
          {
              bitmap: BcsType<number, number, "u16">;
              multisig_pk: BcsStruct<
                  {
                      pk_map: BcsType<
                          {
                              pubKey: EnumOutputShapeWithKeys<
                                  {
                                      ED25519: (...)[];
                                      Passkey: (...)[];
                                      Secp256k1: (...)[];
                                      Secp256r1: (...)[];
                                      ZkLogin: (...)[];
                                  },
                                  "ED25519"
                                  | "Secp256k1"
                                  | "Secp256r1"
                                  | "ZkLogin"
                                  | "Passkey",
                              >;
                              weight: number;
                          }[],
                          Iterable<
                              {
                                  pubKey: EnumInputShape<
                                      {
                                          ED25519: ...;
                                          Passkey: ...;
                                          Secp256k1: ...;
                                          Secp256r1: ...;
                                          ZkLogin: ...;
                                      },
                                  >;
                                  weight: number;
                              },
                              any,
                              any,
                          > & { length: number },
                          string,
                      >;
                      threshold: BcsType<number, number, "u16">;
                  },
                  string,
              >;
              sigs: BcsType<
                  EnumOutputShapeWithKeys<
                      {
                          ED25519: number[];
                          Passkey: number[];
                          Secp256k1: number[];
                          Secp256r1: number[];
                          ZkLogin: number[];
                      },
                      "ED25519"
                      | "Secp256k1"
                      | "Secp256r1"
                      | "ZkLogin"
                      | "Passkey",
                  >[],
                  Iterable<
                      EnumInputShape<
                          {
                              ED25519: Iterable<number, any, any> & { length: number };
                              Passkey: Iterable<number, any, any> & { length: number };
                              Secp256k1: Iterable<number, any, any> & { length: number };
                              Secp256r1: Iterable<number, any, any> & { length: number };
                              ZkLogin: Iterable<number, any, any> & { length: number };
                          },
                      >,
                      any,
                      any,
                  > & { length: number },
                  string,
              >;
          },
          string,
      >
    • MultiSigPkMap: BcsStruct<
          {
              pubKey: BcsEnum<
                  {
                      ED25519: BcsType<
                          number[],
                          Iterable<number, any, any> & { length: number },
                          string,
                      >;
                      Passkey: BcsType<
                          number[],
                          Iterable<number, any, any> & { length: number },
                          string,
                      >;
                      Secp256k1: BcsType<
                          number[],
                          Iterable<number, any, any> & { length: number },
                          string,
                      >;
                      Secp256r1: BcsType<
                          number[],
                          Iterable<number, any, any> & { length: number },
                          string,
                      >;
                      ZkLogin: BcsType<
                          number[],
                          Iterable<number, any, any> & { length: number },
                          string,
                      >;
                  },
                  "PublicKey",
              >;
              weight: BcsType<number, number, "u8">;
          },
          string,
      >
    • MultiSigPublicKey: BcsStruct<
          {
              pk_map: BcsType<
                  {
                      pubKey: EnumOutputShapeWithKeys<
                          {
                              ED25519: number[];
                              Passkey: number[];
                              Secp256k1: number[];
                              Secp256r1: number[];
                              ZkLogin: number[];
                          },
                          "ED25519"
                          | "Secp256k1"
                          | "Secp256r1"
                          | "ZkLogin"
                          | "Passkey",
                      >;
                      weight: number;
                  }[],
                  Iterable<
                      {
                          pubKey: EnumInputShape<
                              {
                                  ED25519: Iterable<(...), (...), (...)> & { length: ... };
                                  Passkey: Iterable<(...), (...), (...)> & { length: ... };
                                  Secp256k1: Iterable<(...), (...), (...)> & { length: ... };
                                  Secp256r1: Iterable<(...), (...), (...)> & { length: ... };
                                  ZkLogin: Iterable<(...), (...), (...)> & { length: ... };
                              },
                          >;
                          weight: number;
                      },
                      any,
                      any,
                  > & { length: number },
                  string,
              >;
              threshold: BcsType<number, number, "u16">;
          },
          string,
      >
    • ObjectArg: BcsEnum<
          {
              ImmOrOwnedObject: BcsStruct<
                  {
                      digest: BcsType<string, string, "ObjectDigest">;
                      objectId: BcsType<
                          string,
                          string
                          | Uint8Array<ArrayBufferLike>,
                          "bytes[32]",
                      >;
                      version: BcsType<string, string | number | bigint, "u64">;
                  },
                  string,
              >;
              Receiving: BcsStruct<
                  {
                      digest: BcsType<string, string, "ObjectDigest">;
                      objectId: BcsType<
                          string,
                          string
                          | Uint8Array<ArrayBufferLike>,
                          "bytes[32]",
                      >;
                      version: BcsType<string, string | number | bigint, "u64">;
                  },
                  string,
              >;
              SharedObject: BcsStruct<
                  {
                      initialSharedVersion: BcsType<
                          string,
                          string
                          | number
                          | bigint,
                          "u64",
                      >;
                      mutable: BcsType<boolean, boolean, "bool">;
                      objectId: BcsType<
                          string,
                          string
                          | Uint8Array<ArrayBufferLike>,
                          "bytes[32]",
                      >;
                  },
                  string,
              >;
          },
          "ObjectArg",
      >
    • ObjectDigest: BcsType<string, string, "ObjectDigest">
    • option: {
          <T extends BcsType<any, any, string>>(
              type: T,
          ): BcsType<
              null
              | InferBcsType<T>,
              undefined | null | InferBcsInput<T>,
              `Option<${T["name"]}>`,
          >;
          <T, Input, Name extends string = string>(
              type: BcsType<T, Input, Name>,
          ): BcsType<null | T, undefined | null | Input>;
      }

      Creates a BcsType representing an optional value

      The BcsType of the optional value

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

      Creates a BcsType representing a variable length vector of a given type

      The BcsType of each element in the vector

      bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]
      
    • bool: function
      • Creates a BcsType that can be used to read and write boolean values.

        Parameters

        Returns BcsType<boolean, boolean, "bool">

        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>, string>

        Returns BcsType<Uint8Array<ArrayBufferLike>, Iterable<number, any, any>, `bytes[${T}]`>

        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>, string>

        Returns BcsType<Uint8Array<ArrayBufferLike>, Iterable<number, any, any>, "vector<u8>">

        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, string>>
        • const Name extends string = string

        Parameters

        • name: Name

          The name of the enum

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

        Returns BcsEnum<T, Name>

        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 ]
    • lazy: function
      • Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.

        Type Parameters

        • T extends BcsType<any, any, string>

        Parameters

        • cb: () => T

          A callback that returns the BcsType

        Returns T

    • string: function
      • Creates a BcsType that can ser/de string values. Strings will be UTF-8 encoded

        Parameters

        Returns BcsType<string, 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, string>>
        • const Name extends string = string

        Parameters

        • name: Name

          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, string> ? U : never
                  },
                  {
                      [K in string
                      | number
                      | symbol]: T[K] extends BcsType<any, U, string> ? U : never
                  },
                  string,
              >,
              "name",
          >

        Returns BcsStruct<T, string>

        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 T extends readonly BcsType<any, any, string>[]
        • const Name extends string = `(${JoinString<
              {
                  [K in string
                  | number
                  | symbol]: T[K<K>] extends BcsType<any, any, T_1> ? T_1 : never
              },
              ", ",
          >})`

        Parameters

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

        Returns BcsTuple<T, Name>

        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

        • Optionaloptions: BcsTypeOptions<string, string | number | bigint, string>

        Returns BcsType<string, string | number | bigint, "u128">

        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, "u16">

        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

        • Optionaloptions: BcsTypeOptions<string, string | number | bigint, string>

        Returns BcsType<string, string | number | bigint, "u256">

        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, "u32">

        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

        • Optionaloptions: BcsTypeOptions<string, string | number | bigint, string>

        Returns BcsType<string, string | number | bigint, "u64">

        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, "u8">

        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, string>