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;
            }>> & {
                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;
            }>> & {
                length: number;
            };
        };
        MoveCall: {
            arguments: Iterable<EnumInputShape<{
                GasCoin: null | boolean | object;
                Input: number;
                NestedResult: readonly [number, number];
                Result: number;
            }>> & {
                length: number;
            };
            function: string;
            module: string;
            package: string | Uint8Array;
            typeArguments: Iterable<string | TypeTag> & {
                length: number;
            };
        };
        Publish: {
            dependencies: Iterable<string | Uint8Array> & {
                length: number;
            };
            modules: Iterable<string | Uint8Array> & {
                length: number;
            };
        };
        SplitCoins: {
            amounts: Iterable<EnumInputShape<{
                GasCoin: null | boolean | object;
                Input: number;
                NestedResult: readonly [number, number];
                Result: number;
            }>> & {
                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;
            }>> & {
                length: number;
            };
        };
        Upgrade: {
            dependencies: Iterable<string | Uint8Array> & {
                length: number;
            };
            modules: Iterable<string | Uint8Array> & {
                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> & {
            length: number;
        };
        Secp256k1: Iterable<number> & {
            length: number;
        };
        Secp256r1: Iterable<number> & {
            length: number;
        };
        ZkLogin: Iterable<number> & {
            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;
        }> & {
            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) => 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_2, any>
            ? U_2
            : 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_3>
            ? U_3
            : 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;
            }> & {
                length: number;
            };
            threshold: number;
        };
        sigs: Iterable<EnumInputShape<{
            ED25519: Iterable<number> & {
                length: number;
            };
            Secp256k1: Iterable<number> & {
                length: number;
            };
            Secp256r1: Iterable<number> & {
                length: number;
            };
            ZkLogin: Iterable<number> & {
                length: number;
            };
        }>> & {
            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> & {
                length: number;
            };
            Secp256k1: Iterable<number> & {
                length: number;
            };
            Secp256r1: Iterable<number> & {
                length: number;
            };
            ZkLogin: Iterable<number> & {
                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> & {
                    length: number;
                };
                Secp256k1: Iterable<number> & {
                    length: number;
                };
                Secp256r1: Iterable<number> & {
                    length: number;
                };
                ZkLogin: Iterable<number> & {
                    length: number;
                };
            }>;
            weight: number;
        }> & {
            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;
        }>> & {
            length: number;
        };
        function: string;
        module: string;
        package: string | Uint8Array;
        typeArguments: Iterable<string | TypeTag> & {
            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<(...)>> & {
                    length: number;
                };
                type: null | string;
            };
            MergeCoins: {
                destination: EnumInputShape<{
                    GasCoin: (...) | (...) | (...) | (...);
                    Input: number;
                    NestedResult: readonly [(...), (...)];
                    Result: number;
                }>;
                sources: Iterable<EnumInputShape<(...)>> & {
                    length: number;
                };
            };
            MoveCall: {
                arguments: Iterable<EnumInputShape<(...)>> & {
                    length: number;
                };
                function: string;
                module: string;
                package: string | Uint8Array;
                typeArguments: Iterable<(...) | (...)> & {
                    length: number;
                };
            };
            Publish: {
                dependencies: Iterable<(...) | (...)> & {
                    length: number;
                };
                modules: Iterable<(...) | (...)> & {
                    length: number;
                };
            };
            SplitCoins: {
                amounts: Iterable<EnumInputShape<(...)>> & {
                    length: number;
                };
                coin: EnumInputShape<{
                    GasCoin: (...) | (...) | (...) | (...);
                    Input: number;
                    NestedResult: readonly [(...), (...)];
                    Result: number;
                }>;
            };
            TransferObjects: {
                address: EnumInputShape<{
                    GasCoin: (...) | (...) | (...) | (...);
                    Input: number;
                    NestedResult: readonly [(...), (...)];
                    Result: number;
                }>;
                objects: Iterable<EnumInputShape<(...)>> & {
                    length: number;
                };
            };
            Upgrade: {
                dependencies: Iterable<(...) | (...)> & {
                    length: number;
                };
                modules: Iterable<(...) | (...)> & {
                    length: number;
                };
                package: string | Uint8Array;
                ticket: EnumInputShape<{
                    GasCoin: (...) | (...) | (...) | (...);
                    Input: number;
                    NestedResult: readonly [(...), (...)];
                    Result: number;
                }>;
            };
        }>> & {
            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;
            };
        }>> & {
            length: number;
        };
    }>;
    PublicKey: BcsType<EnumOutputShapeWithKeys<{
        ED25519: number[];
        Secp256k1: number[];
        Secp256r1: number[];
        ZkLogin: number[];
    }, "ED25519" | "Secp256k1" | "Secp256r1" | "ZkLogin">, EnumInputShape<{
        ED25519: Iterable<number> & {
            length: number;
        };
        Secp256k1: Iterable<number> & {
            length: number;
        };
        Secp256r1: Iterable<number> & {
            length: number;
        };
        ZkLogin: Iterable<number> & {
            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> & {
            length: number;
        };
    }> & {
        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: (...) | (...) | (...);
                        }> & {
                            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> & {
            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> & {
            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;
                }> & {
                    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: ...;
                    }>> & {
                        length: number;
                    };
                    inputs: Iterable<EnumInputShape<{
                        Object: ...;
                        Pure: ...;
                    }>> & {
                        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;
            }> & {
                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: ...;
                    };
                }>> & {
                    length: number;
                };
                inputs: Iterable<EnumInputShape<{
                    Object: EnumInputShape<(...)>;
                    Pure: {
                        bytes: ...;
                    };
                }>> & {
                    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<{
                MutateDeleted: string;
                ReadDeleted: string;
                ReadOnlyRoot: [string, string];
            }, "ReadOnlyRoot" | "MutateDeleted" | "ReadDeleted">][];
        };
    }, "V1" | "V2">, EnumInputShape<{
        V1: {
            created: Iterable<readonly [{
                digest: string;
                objectId: string | Uint8Array;
                version: string | number | bigint;
            }, EnumInputShape<{
                AddressOwner: (...) | (...);
                Immutable: (...) | (...) | (...) | (...);
                ObjectOwner: (...) | (...);
                Shared: {
                    initialSharedVersion: ...;
                };
            }>]> & {
                length: number;
            };
            deleted: Iterable<{
                digest: string;
                objectId: string | Uint8Array;
                version: string | number | bigint;
            }> & {
                length: number;
            };
            dependencies: Iterable<string> & {
                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]> & {
                length: number;
            };
            mutated: Iterable<readonly [{
                digest: string;
                objectId: string | Uint8Array;
                version: string | number | bigint;
            }, EnumInputShape<{
                AddressOwner: (...) | (...);
                Immutable: (...) | (...) | (...) | (...);
                ObjectOwner: (...) | (...);
                Shared: {
                    initialSharedVersion: ...;
                };
            }>]> & {
                length: number;
            };
            sharedObjects: Iterable<{
                digest: string;
                objectId: string | Uint8Array;
                version: string | number | bigint;
            }> & {
                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: ...;
                };
            }>]> & {
                length: number;
            };
            unwrappedThenDeleted: Iterable<{
                digest: string;
                objectId: string | Uint8Array;
                version: string | number | bigint;
            }> & {
                length: number;
            };
            wrapped: Iterable<{
                digest: string;
                objectId: string | Uint8Array;
                version: string | number | bigint;
            }> & {
                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: ...;
                }>;
            }]> & {
                length: number;
            };
            dependencies: Iterable<string> & {
                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<{
                MutateDeleted: (...) | (...) | (...);
                ReadDeleted: (...) | (...) | (...);
                ReadOnlyRoot: readonly [(...), (...)];
            }>]> & {
                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<(...)>;
                };
            }>> & {
                length: number;
            };
            inputs: Iterable<EnumInputShape<{
                Object: EnumInputShape<{
                    ImmOrOwnedObject: ...;
                    Receiving: ...;
                    SharedObject: ...;
                }>;
                Pure: {
                    bytes: (...) | (...);
                };
            }>> & {
                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?): BcsType<boolean, boolean>;
    bytes<T>(size, options?): BcsType<Uint8Array, Uint8Array>;
    enum<T_9>(name, values, options?): BcsType<EnumOutputShape<{
        [K_10 in string | number | symbol]: T_9[K_10] extends BcsType<U_6, any>
            ? U_6
            : true
    }>, EnumInputShape<{
        [K_11 in string | number | symbol]: T_9[K_11] extends BcsType<any, U_7>
            ? U_7
            : null | boolean | object
    }>>;
    fixedArray<T_1, Input>(size, type, options?): BcsType<T_1[], Iterable<Input> & {
        length: number;
    }>;
    lazy<T_10>(cb): T_10;
    map<K_12, V, InputK, InputV>(keyType, valueType): BcsType<Map<K_12, V>, Map<InputK, InputV>>;
    option<T_2, Input_1>(type): BcsType<null | T_2, undefined | null | Input_1>;
    string(options?): BcsType<string, string>;
    struct<T_8>(name, fields, options?): BcsType<{
        [K_6 in string | number | symbol]: T_8[K_6] extends BcsType<U_2, any>
            ? U_2
            : never
    }, {
        [K_7 in string | number | symbol]: T_8[K_7] extends BcsType<any, U_3>
            ? U_3
            : never
    }>;
    tuple<const Types>(types, options?): BcsType<{
        -readonly [K_2 in string | number | symbol]: Types[K_2<K_2>] extends BcsType<T_6, any>
            ? T_6
            : never
    }, {
        [K_3 in string | number | symbol]: Types[K_3<K_3>] extends BcsType<any, T_7>
            ? T_7
            : never
    }>;
    u128(options?): BcsType<string, string | number | bigint>;
    u16(options?): BcsType<number, number>;
    u256(options?): BcsType<string, string | number | bigint>;
    u32(options?): BcsType<number, number>;
    u64(options?): BcsType<string, string | number | bigint>;
    u8(options?): BcsType<number, number>;
    uleb128(options?): BcsType<number, number>;
    vector<T_3, Input_2>(type, options?): BcsType<T_3[], Iterable<Input_2> & {
        length: number;
    }>;
} = ...