Variable bcsConst

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