import type { BcsType } from '@iota/bcs';
import type { TypeTag as TypeTagType } from './types.js';
export declare const Address: BcsType<string, string | Uint8Array, "bytes[32]">;
export declare const ObjectDigest: BcsType<string, string, "ObjectDigest">;
export declare const IotaObjectRef: import("@iota/bcs").BcsStruct<{
    objectId: BcsType<string, string | Uint8Array, "bytes[32]">;
    version: BcsType<string, string | number | bigint, "u64">;
    digest: BcsType<string, string, "ObjectDigest">;
}, string>;
export declare const SharedObjectRef: import("@iota/bcs").BcsStruct<{
    objectId: BcsType<string, string | Uint8Array, "bytes[32]">;
    initialSharedVersion: BcsType<string, string | number | bigint, "u64">;
    mutable: BcsType<boolean, boolean, "bool">;
}, string>;
export declare const ObjectArg: import("@iota/bcs").BcsEnum<{
    ImmOrOwnedObject: import("@iota/bcs").BcsStruct<{
        objectId: BcsType<string, string | Uint8Array, "bytes[32]">;
        version: BcsType<string, string | number | bigint, "u64">;
        digest: BcsType<string, string, "ObjectDigest">;
    }, string>;
    SharedObject: import("@iota/bcs").BcsStruct<{
        objectId: BcsType<string, string | Uint8Array, "bytes[32]">;
        initialSharedVersion: BcsType<string, string | number | bigint, "u64">;
        mutable: BcsType<boolean, boolean, "bool">;
    }, string>;
    Receiving: import("@iota/bcs").BcsStruct<{
        objectId: BcsType<string, string | Uint8Array, "bytes[32]">;
        version: BcsType<string, string | number | bigint, "u64">;
        digest: BcsType<string, string, "ObjectDigest">;
    }, string>;
}, "ObjectArg">;
export declare const Owner: import("@iota/bcs").BcsEnum<{
    AddressOwner: BcsType<string, string | Uint8Array, "bytes[32]">;
    ObjectOwner: BcsType<string, string | Uint8Array, "bytes[32]">;
    Shared: import("@iota/bcs").BcsStruct<{
        initialSharedVersion: BcsType<string, string | number | bigint, "u64">;
    }, string>;
    Immutable: null;
}, "Owner">;
export declare const CallArg: import("@iota/bcs").BcsEnum<{
    Pure: import("@iota/bcs").BcsStruct<{
        bytes: BcsType<string, string | Uint8Array, string>;
    }, string>;
    Object: import("@iota/bcs").BcsEnum<{
        ImmOrOwnedObject: import("@iota/bcs").BcsStruct<{
            objectId: BcsType<string, string | Uint8Array, "bytes[32]">;
            version: BcsType<string, string | number | bigint, "u64">;
            digest: BcsType<string, string, "ObjectDigest">;
        }, string>;
        SharedObject: import("@iota/bcs").BcsStruct<{
            objectId: BcsType<string, string | Uint8Array, "bytes[32]">;
            initialSharedVersion: BcsType<string, string | number | bigint, "u64">;
            mutable: BcsType<boolean, boolean, "bool">;
        }, string>;
        Receiving: import("@iota/bcs").BcsStruct<{
            objectId: BcsType<string, string | Uint8Array, "bytes[32]">;
            version: BcsType<string, string | number | bigint, "u64">;
            digest: BcsType<string, string, "ObjectDigest">;
        }, string>;
    }, "ObjectArg">;
}, "CallArg">;
export declare const TypeTag: BcsType<string, string | TypeTagType, string>;
export declare const Argument: import("@iota/bcs").BcsEnum<{
    GasCoin: null;
    Input: BcsType<number, number, "u16">;
    Result: BcsType<number, number, "u16">;
    NestedResult: import("@iota/bcs").BcsTuple<readonly [BcsType<number, number, "u16">, BcsType<number, number, "u16">], string>;
}, "Argument">;
export declare const ProgrammableMoveCall: import("@iota/bcs").BcsStruct<{
    package: BcsType<string, string | Uint8Array, "bytes[32]">;
    module: BcsType<string, string, string>;
    function: BcsType<string, string, string>;
    typeArguments: BcsType<string[], Iterable<string | TypeTagType> & {
        length: number;
    }, string>;
    arguments: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
        GasCoin: true;
        Input: number;
        Result: number;
        NestedResult: [number, number];
    }, "GasCoin" | "Input" | "Result" | "NestedResult">[], Iterable<import("@iota/bcs").EnumInputShape<{
        GasCoin: boolean | object | null;
        Input: number;
        Result: number;
        NestedResult: readonly [number, number];
    }>> & {
        length: number;
    }, string>;
}, string>;
export declare const Command: import("@iota/bcs").BcsEnum<{
    /**
     * A Move Call - any public Move function can be called via
     * this transaction. The results can be used that instant to pass
     * into the next transaction.
     */
    MoveCall: import("@iota/bcs").BcsStruct<{
        package: BcsType<string, string | Uint8Array, "bytes[32]">;
        module: BcsType<string, string, string>;
        function: BcsType<string, string, string>;
        typeArguments: BcsType<string[], Iterable<string | TypeTagType> & {
            length: number;
        }, string>;
        arguments: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
            GasCoin: true;
            Input: number;
            Result: number;
            NestedResult: [number, number];
        }, "GasCoin" | "Input" | "Result" | "NestedResult">[], Iterable<import("@iota/bcs").EnumInputShape<{
            GasCoin: boolean | object | null;
            Input: number;
            Result: number;
            NestedResult: readonly [number, number];
        }>> & {
            length: number;
        }, string>;
    }, string>;
    /**
     * Transfer vector of objects to a receiver.
     */
    TransferObjects: import("@iota/bcs").BcsStruct<{
        objects: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
            GasCoin: true;
            Input: number;
            Result: number;
            NestedResult: [number, number];
        }, "GasCoin" | "Input" | "Result" | "NestedResult">[], Iterable<import("@iota/bcs").EnumInputShape<{
            GasCoin: boolean | object | null;
            Input: number;
            Result: number;
            NestedResult: readonly [number, number];
        }>> & {
            length: number;
        }, string>;
        address: import("@iota/bcs").BcsEnum<{
            GasCoin: null;
            Input: BcsType<number, number, "u16">;
            Result: BcsType<number, number, "u16">;
            NestedResult: import("@iota/bcs").BcsTuple<readonly [BcsType<number, number, "u16">, BcsType<number, number, "u16">], string>;
        }, "Argument">;
    }, string>;
    SplitCoins: import("@iota/bcs").BcsStruct<{
        coin: import("@iota/bcs").BcsEnum<{
            GasCoin: null;
            Input: BcsType<number, number, "u16">;
            Result: BcsType<number, number, "u16">;
            NestedResult: import("@iota/bcs").BcsTuple<readonly [BcsType<number, number, "u16">, BcsType<number, number, "u16">], string>;
        }, "Argument">;
        amounts: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
            GasCoin: true;
            Input: number;
            Result: number;
            NestedResult: [number, number];
        }, "GasCoin" | "Input" | "Result" | "NestedResult">[], Iterable<import("@iota/bcs").EnumInputShape<{
            GasCoin: boolean | object | null;
            Input: number;
            Result: number;
            NestedResult: readonly [number, number];
        }>> & {
            length: number;
        }, string>;
    }, string>;
    MergeCoins: import("@iota/bcs").BcsStruct<{
        destination: import("@iota/bcs").BcsEnum<{
            GasCoin: null;
            Input: BcsType<number, number, "u16">;
            Result: BcsType<number, number, "u16">;
            NestedResult: import("@iota/bcs").BcsTuple<readonly [BcsType<number, number, "u16">, BcsType<number, number, "u16">], string>;
        }, "Argument">;
        sources: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
            GasCoin: true;
            Input: number;
            Result: number;
            NestedResult: [number, number];
        }, "GasCoin" | "Input" | "Result" | "NestedResult">[], Iterable<import("@iota/bcs").EnumInputShape<{
            GasCoin: boolean | object | null;
            Input: number;
            Result: number;
            NestedResult: readonly [number, number];
        }>> & {
            length: number;
        }, string>;
    }, string>;
    Publish: import("@iota/bcs").BcsStruct<{
        modules: BcsType<string[], Iterable<string | Uint8Array> & {
            length: number;
        }, string>;
        dependencies: BcsType<string[], Iterable<string | Uint8Array> & {
            length: number;
        }, string>;
    }, string>;
    MakeMoveVec: import("@iota/bcs").BcsStruct<{
        type: BcsType<string | null, string | null, string>;
        elements: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
            GasCoin: true;
            Input: number;
            Result: number;
            NestedResult: [number, number];
        }, "GasCoin" | "Input" | "Result" | "NestedResult">[], Iterable<import("@iota/bcs").EnumInputShape<{
            GasCoin: boolean | object | null;
            Input: number;
            Result: number;
            NestedResult: readonly [number, number];
        }>> & {
            length: number;
        }, string>;
    }, string>;
    Upgrade: import("@iota/bcs").BcsStruct<{
        modules: BcsType<string[], Iterable<string | Uint8Array> & {
            length: number;
        }, string>;
        dependencies: BcsType<string[], Iterable<string | Uint8Array> & {
            length: number;
        }, string>;
        package: BcsType<string, string | Uint8Array, "bytes[32]">;
        ticket: import("@iota/bcs").BcsEnum<{
            GasCoin: null;
            Input: BcsType<number, number, "u16">;
            Result: BcsType<number, number, "u16">;
            NestedResult: import("@iota/bcs").BcsTuple<readonly [BcsType<number, number, "u16">, BcsType<number, number, "u16">], string>;
        }, "Argument">;
    }, string>;
}, "Command">;
export declare const ProgrammableTransaction: import("@iota/bcs").BcsStruct<{
    inputs: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
        Pure: {
            bytes: string;
        };
        Object: import("@iota/bcs").EnumOutputShapeWithKeys<{
            ImmOrOwnedObject: {
                objectId: string;
                version: string;
                digest: string;
            };
            SharedObject: {
                objectId: string;
                initialSharedVersion: string;
                mutable: boolean;
            };
            Receiving: {
                objectId: string;
                version: string;
                digest: string;
            };
        }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
    }, "Pure" | "Object">[], Iterable<import("@iota/bcs").EnumInputShape<{
        Pure: {
            bytes: string | Uint8Array;
        };
        Object: import("@iota/bcs").EnumInputShape<{
            ImmOrOwnedObject: {
                objectId: string | Uint8Array;
                version: string | number | bigint;
                digest: string;
            };
            SharedObject: {
                objectId: string | Uint8Array;
                initialSharedVersion: string | number | bigint;
                mutable: boolean;
            };
            Receiving: {
                objectId: string | Uint8Array;
                version: string | number | bigint;
                digest: string;
            };
        }>;
    }>> & {
        length: number;
    }, string>;
    commands: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
        MoveCall: {
            package: string;
            module: string;
            function: string;
            typeArguments: string[];
            arguments: import("@iota/bcs").EnumOutputShapeWithKeys<{
                GasCoin: true;
                Input: number;
                Result: number;
                NestedResult: [number, number];
            }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
        };
        TransferObjects: {
            objects: import("@iota/bcs").EnumOutputShapeWithKeys<{
                GasCoin: true;
                Input: number;
                Result: number;
                NestedResult: [number, number];
            }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
            address: import("@iota/bcs").EnumOutputShapeWithKeys<{
                GasCoin: true;
                Input: number;
                Result: number;
                NestedResult: [number, number];
            }, "GasCoin" | "Input" | "Result" | "NestedResult">;
        };
        SplitCoins: {
            coin: import("@iota/bcs").EnumOutputShapeWithKeys<{
                GasCoin: true;
                Input: number;
                Result: number;
                NestedResult: [number, number];
            }, "GasCoin" | "Input" | "Result" | "NestedResult">;
            amounts: import("@iota/bcs").EnumOutputShapeWithKeys<{
                GasCoin: true;
                Input: number;
                Result: number;
                NestedResult: [number, number];
            }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
        };
        MergeCoins: {
            destination: import("@iota/bcs").EnumOutputShapeWithKeys<{
                GasCoin: true;
                Input: number;
                Result: number;
                NestedResult: [number, number];
            }, "GasCoin" | "Input" | "Result" | "NestedResult">;
            sources: import("@iota/bcs").EnumOutputShapeWithKeys<{
                GasCoin: true;
                Input: number;
                Result: number;
                NestedResult: [number, number];
            }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
        };
        Publish: {
            modules: string[];
            dependencies: string[];
        };
        MakeMoveVec: {
            type: string | null;
            elements: import("@iota/bcs").EnumOutputShapeWithKeys<{
                GasCoin: true;
                Input: number;
                Result: number;
                NestedResult: [number, number];
            }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
        };
        Upgrade: {
            modules: string[];
            dependencies: string[];
            package: string;
            ticket: import("@iota/bcs").EnumOutputShapeWithKeys<{
                GasCoin: true;
                Input: number;
                Result: number;
                NestedResult: [number, number];
            }, "GasCoin" | "Input" | "Result" | "NestedResult">;
        };
    }, "MoveCall" | "TransferObjects" | "SplitCoins" | "MergeCoins" | "Publish" | "MakeMoveVec" | "Upgrade">[], Iterable<import("@iota/bcs").EnumInputShape<{
        MoveCall: {
            package: string | Uint8Array;
            module: string;
            function: string;
            typeArguments: Iterable<string | TypeTagType> & {
                length: number;
            };
            arguments: Iterable<import("@iota/bcs").EnumInputShape<{
                GasCoin: boolean | object | null;
                Input: number;
                Result: number;
                NestedResult: readonly [number, number];
            }>> & {
                length: number;
            };
        };
        TransferObjects: {
            objects: Iterable<import("@iota/bcs").EnumInputShape<{
                GasCoin: boolean | object | null;
                Input: number;
                Result: number;
                NestedResult: readonly [number, number];
            }>> & {
                length: number;
            };
            address: import("@iota/bcs").EnumInputShape<{
                GasCoin: boolean | object | null;
                Input: number;
                Result: number;
                NestedResult: readonly [number, number];
            }>;
        };
        SplitCoins: {
            coin: import("@iota/bcs").EnumInputShape<{
                GasCoin: boolean | object | null;
                Input: number;
                Result: number;
                NestedResult: readonly [number, number];
            }>;
            amounts: Iterable<import("@iota/bcs").EnumInputShape<{
                GasCoin: boolean | object | null;
                Input: number;
                Result: number;
                NestedResult: readonly [number, number];
            }>> & {
                length: number;
            };
        };
        MergeCoins: {
            destination: import("@iota/bcs").EnumInputShape<{
                GasCoin: boolean | object | null;
                Input: number;
                Result: number;
                NestedResult: readonly [number, number];
            }>;
            sources: Iterable<import("@iota/bcs").EnumInputShape<{
                GasCoin: boolean | object | null;
                Input: number;
                Result: number;
                NestedResult: readonly [number, number];
            }>> & {
                length: number;
            };
        };
        Publish: {
            modules: Iterable<string | Uint8Array> & {
                length: number;
            };
            dependencies: Iterable<string | Uint8Array> & {
                length: number;
            };
        };
        MakeMoveVec: {
            type: string | null;
            elements: Iterable<import("@iota/bcs").EnumInputShape<{
                GasCoin: boolean | object | null;
                Input: number;
                Result: number;
                NestedResult: readonly [number, number];
            }>> & {
                length: number;
            };
        };
        Upgrade: {
            modules: Iterable<string | Uint8Array> & {
                length: number;
            };
            dependencies: Iterable<string | Uint8Array> & {
                length: number;
            };
            package: string | Uint8Array;
            ticket: import("@iota/bcs").EnumInputShape<{
                GasCoin: boolean | object | null;
                Input: number;
                Result: number;
                NestedResult: readonly [number, number];
            }>;
        };
    }>> & {
        length: number;
    }, string>;
}, string>;
export declare const TransactionKind: import("@iota/bcs").BcsEnum<{
    ProgrammableTransaction: import("@iota/bcs").BcsStruct<{
        inputs: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
            Pure: {
                bytes: string;
            };
            Object: import("@iota/bcs").EnumOutputShapeWithKeys<{
                ImmOrOwnedObject: {
                    objectId: string;
                    version: string;
                    digest: string;
                };
                SharedObject: {
                    objectId: string;
                    initialSharedVersion: string;
                    mutable: boolean;
                };
                Receiving: {
                    objectId: string;
                    version: string;
                    digest: string;
                };
            }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
        }, "Pure" | "Object">[], Iterable<import("@iota/bcs").EnumInputShape<{
            Pure: {
                bytes: string | Uint8Array;
            };
            Object: import("@iota/bcs").EnumInputShape<{
                ImmOrOwnedObject: {
                    objectId: string | Uint8Array;
                    version: string | number | bigint;
                    digest: string;
                };
                SharedObject: {
                    objectId: string | Uint8Array;
                    initialSharedVersion: string | number | bigint;
                    mutable: boolean;
                };
                Receiving: {
                    objectId: string | Uint8Array;
                    version: string | number | bigint;
                    digest: string;
                };
            }>;
        }>> & {
            length: number;
        }, string>;
        commands: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
            MoveCall: {
                package: string;
                module: string;
                function: string;
                typeArguments: string[];
                arguments: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    GasCoin: true;
                    Input: number;
                    Result: number;
                    NestedResult: [number, number];
                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
            };
            TransferObjects: {
                objects: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    GasCoin: true;
                    Input: number;
                    Result: number;
                    NestedResult: [number, number];
                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                address: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    GasCoin: true;
                    Input: number;
                    Result: number;
                    NestedResult: [number, number];
                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
            };
            SplitCoins: {
                coin: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    GasCoin: true;
                    Input: number;
                    Result: number;
                    NestedResult: [number, number];
                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                amounts: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    GasCoin: true;
                    Input: number;
                    Result: number;
                    NestedResult: [number, number];
                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
            };
            MergeCoins: {
                destination: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    GasCoin: true;
                    Input: number;
                    Result: number;
                    NestedResult: [number, number];
                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                sources: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    GasCoin: true;
                    Input: number;
                    Result: number;
                    NestedResult: [number, number];
                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
            };
            Publish: {
                modules: string[];
                dependencies: string[];
            };
            MakeMoveVec: {
                type: string | null;
                elements: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    GasCoin: true;
                    Input: number;
                    Result: number;
                    NestedResult: [number, number];
                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
            };
            Upgrade: {
                modules: string[];
                dependencies: string[];
                package: string;
                ticket: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    GasCoin: true;
                    Input: number;
                    Result: number;
                    NestedResult: [number, number];
                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
            };
        }, "MoveCall" | "TransferObjects" | "SplitCoins" | "MergeCoins" | "Publish" | "MakeMoveVec" | "Upgrade">[], Iterable<import("@iota/bcs").EnumInputShape<{
            MoveCall: {
                package: string | Uint8Array;
                module: string;
                function: string;
                typeArguments: Iterable<string | TypeTagType> & {
                    length: number;
                };
                arguments: Iterable<import("@iota/bcs").EnumInputShape<{
                    GasCoin: boolean | object | null;
                    Input: number;
                    Result: number;
                    NestedResult: readonly [number, number];
                }>> & {
                    length: number;
                };
            };
            TransferObjects: {
                objects: Iterable<import("@iota/bcs").EnumInputShape<{
                    GasCoin: boolean | object | null;
                    Input: number;
                    Result: number;
                    NestedResult: readonly [number, number];
                }>> & {
                    length: number;
                };
                address: import("@iota/bcs").EnumInputShape<{
                    GasCoin: boolean | object | null;
                    Input: number;
                    Result: number;
                    NestedResult: readonly [number, number];
                }>;
            };
            SplitCoins: {
                coin: import("@iota/bcs").EnumInputShape<{
                    GasCoin: boolean | object | null;
                    Input: number;
                    Result: number;
                    NestedResult: readonly [number, number];
                }>;
                amounts: Iterable<import("@iota/bcs").EnumInputShape<{
                    GasCoin: boolean | object | null;
                    Input: number;
                    Result: number;
                    NestedResult: readonly [number, number];
                }>> & {
                    length: number;
                };
            };
            MergeCoins: {
                destination: import("@iota/bcs").EnumInputShape<{
                    GasCoin: boolean | object | null;
                    Input: number;
                    Result: number;
                    NestedResult: readonly [number, number];
                }>;
                sources: Iterable<import("@iota/bcs").EnumInputShape<{
                    GasCoin: boolean | object | null;
                    Input: number;
                    Result: number;
                    NestedResult: readonly [number, number];
                }>> & {
                    length: number;
                };
            };
            Publish: {
                modules: Iterable<string | Uint8Array> & {
                    length: number;
                };
                dependencies: Iterable<string | Uint8Array> & {
                    length: number;
                };
            };
            MakeMoveVec: {
                type: string | null;
                elements: Iterable<import("@iota/bcs").EnumInputShape<{
                    GasCoin: boolean | object | null;
                    Input: number;
                    Result: number;
                    NestedResult: readonly [number, number];
                }>> & {
                    length: number;
                };
            };
            Upgrade: {
                modules: Iterable<string | Uint8Array> & {
                    length: number;
                };
                dependencies: Iterable<string | Uint8Array> & {
                    length: number;
                };
                package: string | Uint8Array;
                ticket: import("@iota/bcs").EnumInputShape<{
                    GasCoin: boolean | object | null;
                    Input: number;
                    Result: number;
                    NestedResult: readonly [number, number];
                }>;
            };
        }>> & {
            length: number;
        }, string>;
    }, string>;
    ChangeEpoch: null;
    Genesis: null;
    ConsensusCommitPrologue: null;
}, "TransactionKind">;
export declare const TransactionExpiration: import("@iota/bcs").BcsEnum<{
    None: null;
    Epoch: BcsType<number, string | number, "u64">;
}, "TransactionExpiration">;
export declare const StructTag: import("@iota/bcs").BcsStruct<{
    address: BcsType<string, string | Uint8Array, "bytes[32]">;
    module: BcsType<string, string, string>;
    name: BcsType<string, string, string>;
    typeParams: BcsType<TypeTagType[], Iterable<TypeTagType> & {
        length: number;
    }, string>;
}, string>;
export declare const GasData: import("@iota/bcs").BcsStruct<{
    payment: BcsType<{
        objectId: string;
        version: string;
        digest: string;
    }[], Iterable<{
        objectId: string | Uint8Array;
        version: string | number | bigint;
        digest: string;
    }> & {
        length: number;
    }, string>;
    owner: BcsType<string, string | Uint8Array, "bytes[32]">;
    price: BcsType<string, string | number | bigint, "u64">;
    budget: BcsType<string, string | number | bigint, "u64">;
}, string>;
export declare const TransactionDataV1: import("@iota/bcs").BcsStruct<{
    kind: import("@iota/bcs").BcsEnum<{
        ProgrammableTransaction: import("@iota/bcs").BcsStruct<{
            inputs: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
                Pure: {
                    bytes: string;
                };
                Object: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    ImmOrOwnedObject: {
                        objectId: string;
                        version: string;
                        digest: string;
                    };
                    SharedObject: {
                        objectId: string;
                        initialSharedVersion: string;
                        mutable: boolean;
                    };
                    Receiving: {
                        objectId: string;
                        version: string;
                        digest: string;
                    };
                }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
            }, "Pure" | "Object">[], Iterable<import("@iota/bcs").EnumInputShape<{
                Pure: {
                    bytes: string | Uint8Array;
                };
                Object: import("@iota/bcs").EnumInputShape<{
                    ImmOrOwnedObject: {
                        objectId: string | Uint8Array;
                        version: string | number | bigint;
                        digest: string;
                    };
                    SharedObject: {
                        objectId: string | Uint8Array;
                        initialSharedVersion: string | number | bigint;
                        mutable: boolean;
                    };
                    Receiving: {
                        objectId: string | Uint8Array;
                        version: string | number | bigint;
                        digest: string;
                    };
                }>;
            }>> & {
                length: number;
            }, string>;
            commands: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
                MoveCall: {
                    package: string;
                    module: string;
                    function: string;
                    typeArguments: string[];
                    arguments: import("@iota/bcs").EnumOutputShapeWithKeys<{
                        GasCoin: true;
                        Input: number;
                        Result: number;
                        NestedResult: [number, number];
                    }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                };
                TransferObjects: {
                    objects: import("@iota/bcs").EnumOutputShapeWithKeys<{
                        GasCoin: true;
                        Input: number;
                        Result: number;
                        NestedResult: [number, number];
                    }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                    address: import("@iota/bcs").EnumOutputShapeWithKeys<{
                        GasCoin: true;
                        Input: number;
                        Result: number;
                        NestedResult: [number, number];
                    }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                };
                SplitCoins: {
                    coin: import("@iota/bcs").EnumOutputShapeWithKeys<{
                        GasCoin: true;
                        Input: number;
                        Result: number;
                        NestedResult: [number, number];
                    }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                    amounts: import("@iota/bcs").EnumOutputShapeWithKeys<{
                        GasCoin: true;
                        Input: number;
                        Result: number;
                        NestedResult: [number, number];
                    }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                };
                MergeCoins: {
                    destination: import("@iota/bcs").EnumOutputShapeWithKeys<{
                        GasCoin: true;
                        Input: number;
                        Result: number;
                        NestedResult: [number, number];
                    }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                    sources: import("@iota/bcs").EnumOutputShapeWithKeys<{
                        GasCoin: true;
                        Input: number;
                        Result: number;
                        NestedResult: [number, number];
                    }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                };
                Publish: {
                    modules: string[];
                    dependencies: string[];
                };
                MakeMoveVec: {
                    type: string | null;
                    elements: import("@iota/bcs").EnumOutputShapeWithKeys<{
                        GasCoin: true;
                        Input: number;
                        Result: number;
                        NestedResult: [number, number];
                    }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                };
                Upgrade: {
                    modules: string[];
                    dependencies: string[];
                    package: string;
                    ticket: import("@iota/bcs").EnumOutputShapeWithKeys<{
                        GasCoin: true;
                        Input: number;
                        Result: number;
                        NestedResult: [number, number];
                    }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                };
            }, "MoveCall" | "TransferObjects" | "SplitCoins" | "MergeCoins" | "Publish" | "MakeMoveVec" | "Upgrade">[], Iterable<import("@iota/bcs").EnumInputShape<{
                MoveCall: {
                    package: string | Uint8Array;
                    module: string;
                    function: string;
                    typeArguments: Iterable<string | TypeTagType> & {
                        length: number;
                    };
                    arguments: Iterable<import("@iota/bcs").EnumInputShape<{
                        GasCoin: boolean | object | null;
                        Input: number;
                        Result: number;
                        NestedResult: readonly [number, number];
                    }>> & {
                        length: number;
                    };
                };
                TransferObjects: {
                    objects: Iterable<import("@iota/bcs").EnumInputShape<{
                        GasCoin: boolean | object | null;
                        Input: number;
                        Result: number;
                        NestedResult: readonly [number, number];
                    }>> & {
                        length: number;
                    };
                    address: import("@iota/bcs").EnumInputShape<{
                        GasCoin: boolean | object | null;
                        Input: number;
                        Result: number;
                        NestedResult: readonly [number, number];
                    }>;
                };
                SplitCoins: {
                    coin: import("@iota/bcs").EnumInputShape<{
                        GasCoin: boolean | object | null;
                        Input: number;
                        Result: number;
                        NestedResult: readonly [number, number];
                    }>;
                    amounts: Iterable<import("@iota/bcs").EnumInputShape<{
                        GasCoin: boolean | object | null;
                        Input: number;
                        Result: number;
                        NestedResult: readonly [number, number];
                    }>> & {
                        length: number;
                    };
                };
                MergeCoins: {
                    destination: import("@iota/bcs").EnumInputShape<{
                        GasCoin: boolean | object | null;
                        Input: number;
                        Result: number;
                        NestedResult: readonly [number, number];
                    }>;
                    sources: Iterable<import("@iota/bcs").EnumInputShape<{
                        GasCoin: boolean | object | null;
                        Input: number;
                        Result: number;
                        NestedResult: readonly [number, number];
                    }>> & {
                        length: number;
                    };
                };
                Publish: {
                    modules: Iterable<string | Uint8Array> & {
                        length: number;
                    };
                    dependencies: Iterable<string | Uint8Array> & {
                        length: number;
                    };
                };
                MakeMoveVec: {
                    type: string | null;
                    elements: Iterable<import("@iota/bcs").EnumInputShape<{
                        GasCoin: boolean | object | null;
                        Input: number;
                        Result: number;
                        NestedResult: readonly [number, number];
                    }>> & {
                        length: number;
                    };
                };
                Upgrade: {
                    modules: Iterable<string | Uint8Array> & {
                        length: number;
                    };
                    dependencies: Iterable<string | Uint8Array> & {
                        length: number;
                    };
                    package: string | Uint8Array;
                    ticket: import("@iota/bcs").EnumInputShape<{
                        GasCoin: boolean | object | null;
                        Input: number;
                        Result: number;
                        NestedResult: readonly [number, number];
                    }>;
                };
            }>> & {
                length: number;
            }, string>;
        }, string>;
        ChangeEpoch: null;
        Genesis: null;
        ConsensusCommitPrologue: null;
    }, "TransactionKind">;
    sender: BcsType<string, string | Uint8Array, "bytes[32]">;
    gasData: import("@iota/bcs").BcsStruct<{
        payment: BcsType<{
            objectId: string;
            version: string;
            digest: string;
        }[], Iterable<{
            objectId: string | Uint8Array;
            version: string | number | bigint;
            digest: string;
        }> & {
            length: number;
        }, string>;
        owner: BcsType<string, string | Uint8Array, "bytes[32]">;
        price: BcsType<string, string | number | bigint, "u64">;
        budget: BcsType<string, string | number | bigint, "u64">;
    }, string>;
    expiration: import("@iota/bcs").BcsEnum<{
        None: null;
        Epoch: BcsType<number, string | number, "u64">;
    }, "TransactionExpiration">;
}, string>;
export declare const TransactionData: import("@iota/bcs").BcsEnum<{
    V1: import("@iota/bcs").BcsStruct<{
        kind: import("@iota/bcs").BcsEnum<{
            ProgrammableTransaction: import("@iota/bcs").BcsStruct<{
                inputs: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
                    Pure: {
                        bytes: string;
                    };
                    Object: import("@iota/bcs").EnumOutputShapeWithKeys<{
                        ImmOrOwnedObject: {
                            objectId: string;
                            version: string;
                            digest: string;
                        };
                        SharedObject: {
                            objectId: string;
                            initialSharedVersion: string;
                            mutable: boolean;
                        };
                        Receiving: {
                            objectId: string;
                            version: string;
                            digest: string;
                        };
                    }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
                }, "Pure" | "Object">[], Iterable<import("@iota/bcs").EnumInputShape<{
                    Pure: {
                        bytes: string | Uint8Array;
                    };
                    Object: import("@iota/bcs").EnumInputShape<{
                        ImmOrOwnedObject: {
                            objectId: string | Uint8Array;
                            version: string | number | bigint;
                            digest: string;
                        };
                        SharedObject: {
                            objectId: string | Uint8Array;
                            initialSharedVersion: string | number | bigint;
                            mutable: boolean;
                        };
                        Receiving: {
                            objectId: string | Uint8Array;
                            version: string | number | bigint;
                            digest: string;
                        };
                    }>;
                }>> & {
                    length: number;
                }, string>;
                commands: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
                    MoveCall: {
                        package: string;
                        module: string;
                        function: string;
                        typeArguments: string[];
                        arguments: import("@iota/bcs").EnumOutputShapeWithKeys<{
                            GasCoin: true;
                            Input: number;
                            Result: number;
                            NestedResult: [number, number];
                        }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                    };
                    TransferObjects: {
                        objects: import("@iota/bcs").EnumOutputShapeWithKeys<{
                            GasCoin: true;
                            Input: number;
                            Result: number;
                            NestedResult: [number, number];
                        }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                        address: import("@iota/bcs").EnumOutputShapeWithKeys<{
                            GasCoin: true;
                            Input: number;
                            Result: number;
                            NestedResult: [number, number];
                        }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                    };
                    SplitCoins: {
                        coin: import("@iota/bcs").EnumOutputShapeWithKeys<{
                            GasCoin: true;
                            Input: number;
                            Result: number;
                            NestedResult: [number, number];
                        }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                        amounts: import("@iota/bcs").EnumOutputShapeWithKeys<{
                            GasCoin: true;
                            Input: number;
                            Result: number;
                            NestedResult: [number, number];
                        }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                    };
                    MergeCoins: {
                        destination: import("@iota/bcs").EnumOutputShapeWithKeys<{
                            GasCoin: true;
                            Input: number;
                            Result: number;
                            NestedResult: [number, number];
                        }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                        sources: import("@iota/bcs").EnumOutputShapeWithKeys<{
                            GasCoin: true;
                            Input: number;
                            Result: number;
                            NestedResult: [number, number];
                        }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                    };
                    Publish: {
                        modules: string[];
                        dependencies: string[];
                    };
                    MakeMoveVec: {
                        type: string | null;
                        elements: import("@iota/bcs").EnumOutputShapeWithKeys<{
                            GasCoin: true;
                            Input: number;
                            Result: number;
                            NestedResult: [number, number];
                        }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                    };
                    Upgrade: {
                        modules: string[];
                        dependencies: string[];
                        package: string;
                        ticket: import("@iota/bcs").EnumOutputShapeWithKeys<{
                            GasCoin: true;
                            Input: number;
                            Result: number;
                            NestedResult: [number, number];
                        }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                    };
                }, "MoveCall" | "TransferObjects" | "SplitCoins" | "MergeCoins" | "Publish" | "MakeMoveVec" | "Upgrade">[], Iterable<import("@iota/bcs").EnumInputShape<{
                    MoveCall: {
                        package: string | Uint8Array;
                        module: string;
                        function: string;
                        typeArguments: Iterable<string | TypeTagType> & {
                            length: number;
                        };
                        arguments: Iterable<import("@iota/bcs").EnumInputShape<{
                            GasCoin: boolean | object | null;
                            Input: number;
                            Result: number;
                            NestedResult: readonly [number, number];
                        }>> & {
                            length: number;
                        };
                    };
                    TransferObjects: {
                        objects: Iterable<import("@iota/bcs").EnumInputShape<{
                            GasCoin: boolean | object | null;
                            Input: number;
                            Result: number;
                            NestedResult: readonly [number, number];
                        }>> & {
                            length: number;
                        };
                        address: import("@iota/bcs").EnumInputShape<{
                            GasCoin: boolean | object | null;
                            Input: number;
                            Result: number;
                            NestedResult: readonly [number, number];
                        }>;
                    };
                    SplitCoins: {
                        coin: import("@iota/bcs").EnumInputShape<{
                            GasCoin: boolean | object | null;
                            Input: number;
                            Result: number;
                            NestedResult: readonly [number, number];
                        }>;
                        amounts: Iterable<import("@iota/bcs").EnumInputShape<{
                            GasCoin: boolean | object | null;
                            Input: number;
                            Result: number;
                            NestedResult: readonly [number, number];
                        }>> & {
                            length: number;
                        };
                    };
                    MergeCoins: {
                        destination: import("@iota/bcs").EnumInputShape<{
                            GasCoin: boolean | object | null;
                            Input: number;
                            Result: number;
                            NestedResult: readonly [number, number];
                        }>;
                        sources: Iterable<import("@iota/bcs").EnumInputShape<{
                            GasCoin: boolean | object | null;
                            Input: number;
                            Result: number;
                            NestedResult: readonly [number, number];
                        }>> & {
                            length: number;
                        };
                    };
                    Publish: {
                        modules: Iterable<string | Uint8Array> & {
                            length: number;
                        };
                        dependencies: Iterable<string | Uint8Array> & {
                            length: number;
                        };
                    };
                    MakeMoveVec: {
                        type: string | null;
                        elements: Iterable<import("@iota/bcs").EnumInputShape<{
                            GasCoin: boolean | object | null;
                            Input: number;
                            Result: number;
                            NestedResult: readonly [number, number];
                        }>> & {
                            length: number;
                        };
                    };
                    Upgrade: {
                        modules: Iterable<string | Uint8Array> & {
                            length: number;
                        };
                        dependencies: Iterable<string | Uint8Array> & {
                            length: number;
                        };
                        package: string | Uint8Array;
                        ticket: import("@iota/bcs").EnumInputShape<{
                            GasCoin: boolean | object | null;
                            Input: number;
                            Result: number;
                            NestedResult: readonly [number, number];
                        }>;
                    };
                }>> & {
                    length: number;
                }, string>;
            }, string>;
            ChangeEpoch: null;
            Genesis: null;
            ConsensusCommitPrologue: null;
        }, "TransactionKind">;
        sender: BcsType<string, string | Uint8Array, "bytes[32]">;
        gasData: import("@iota/bcs").BcsStruct<{
            payment: BcsType<{
                objectId: string;
                version: string;
                digest: string;
            }[], Iterable<{
                objectId: string | Uint8Array;
                version: string | number | bigint;
                digest: string;
            }> & {
                length: number;
            }, string>;
            owner: BcsType<string, string | Uint8Array, "bytes[32]">;
            price: BcsType<string, string | number | bigint, "u64">;
            budget: BcsType<string, string | number | bigint, "u64">;
        }, string>;
        expiration: import("@iota/bcs").BcsEnum<{
            None: null;
            Epoch: BcsType<number, string | number, "u64">;
        }, "TransactionExpiration">;
    }, string>;
}, "TransactionData">;
export declare const IntentScope: import("@iota/bcs").BcsEnum<{
    TransactionData: null;
    TransactionEffects: null;
    CheckpointSummary: null;
    PersonalMessage: null;
}, "IntentScope">;
export declare const IntentVersion: import("@iota/bcs").BcsEnum<{
    V0: null;
}, "IntentVersion">;
export declare const AppId: import("@iota/bcs").BcsEnum<{
    Iota: null;
}, "AppId">;
export declare const Intent: import("@iota/bcs").BcsStruct<{
    scope: import("@iota/bcs").BcsEnum<{
        TransactionData: null;
        TransactionEffects: null;
        CheckpointSummary: null;
        PersonalMessage: null;
    }, "IntentScope">;
    version: import("@iota/bcs").BcsEnum<{
        V0: null;
    }, "IntentVersion">;
    appId: import("@iota/bcs").BcsEnum<{
        Iota: null;
    }, "AppId">;
}, string>;
export declare function IntentMessage<T extends BcsType<any>>(T: T): import("@iota/bcs").BcsStruct<{
    intent: import("@iota/bcs").BcsStruct<{
        scope: import("@iota/bcs").BcsEnum<{
            TransactionData: null;
            TransactionEffects: null;
            CheckpointSummary: null;
            PersonalMessage: null;
        }, "IntentScope">;
        version: import("@iota/bcs").BcsEnum<{
            V0: null;
        }, "IntentVersion">;
        appId: import("@iota/bcs").BcsEnum<{
            Iota: null;
        }, "AppId">;
    }, string>;
    value: T;
}, string>;
export declare const CompressedSignature: import("@iota/bcs").BcsEnum<{
    ED25519: BcsType<Uint8Array, Iterable<number>, "bytes[64]">;
    Secp256k1: BcsType<Uint8Array, Iterable<number>, "bytes[64]">;
    Secp256r1: BcsType<Uint8Array, Iterable<number>, "bytes[64]">;
}, "CompressedSignature">;
export declare const PublicKey: import("@iota/bcs").BcsEnum<{
    ED25519: BcsType<Uint8Array, Iterable<number>, "bytes[32]">;
    Secp256k1: BcsType<Uint8Array, Iterable<number>, "bytes[33]">;
    Secp256r1: BcsType<Uint8Array, Iterable<number>, "bytes[33]">;
}, "PublicKey">;
export declare const MultiSigPkMap: import("@iota/bcs").BcsStruct<{
    pubKey: import("@iota/bcs").BcsEnum<{
        ED25519: BcsType<Uint8Array, Iterable<number>, "bytes[32]">;
        Secp256k1: BcsType<Uint8Array, Iterable<number>, "bytes[33]">;
        Secp256r1: BcsType<Uint8Array, Iterable<number>, "bytes[33]">;
    }, "PublicKey">;
    weight: BcsType<number, number, "u8">;
}, string>;
export declare const MultiSigPublicKey: import("@iota/bcs").BcsStruct<{
    pk_map: BcsType<{
        pubKey: import("@iota/bcs").EnumOutputShapeWithKeys<{
            ED25519: Uint8Array;
            Secp256k1: Uint8Array;
            Secp256r1: Uint8Array;
        }, "ED25519" | "Secp256k1" | "Secp256r1">;
        weight: number;
    }[], Iterable<{
        pubKey: import("@iota/bcs").EnumInputShape<{
            ED25519: Iterable<number>;
            Secp256k1: Iterable<number>;
            Secp256r1: Iterable<number>;
        }>;
        weight: number;
    }> & {
        length: number;
    }, string>;
    threshold: BcsType<number, number, "u16">;
}, string>;
export declare const MultiSig: import("@iota/bcs").BcsStruct<{
    sigs: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
        ED25519: Uint8Array;
        Secp256k1: Uint8Array;
        Secp256r1: Uint8Array;
    }, "ED25519" | "Secp256k1" | "Secp256r1">[], Iterable<import("@iota/bcs").EnumInputShape<{
        ED25519: Iterable<number>;
        Secp256k1: Iterable<number>;
        Secp256r1: Iterable<number>;
    }>> & {
        length: number;
    }, string>;
    bitmap: BcsType<number, number, "u16">;
    multisig_pk: import("@iota/bcs").BcsStruct<{
        pk_map: BcsType<{
            pubKey: import("@iota/bcs").EnumOutputShapeWithKeys<{
                ED25519: Uint8Array;
                Secp256k1: Uint8Array;
                Secp256r1: Uint8Array;
            }, "ED25519" | "Secp256k1" | "Secp256r1">;
            weight: number;
        }[], Iterable<{
            pubKey: import("@iota/bcs").EnumInputShape<{
                ED25519: Iterable<number>;
                Secp256k1: Iterable<number>;
                Secp256r1: Iterable<number>;
            }>;
            weight: number;
        }> & {
            length: number;
        }, string>;
        threshold: BcsType<number, number, "u16">;
    }, string>;
}, string>;
export declare const base64String: BcsType<string, string | Uint8Array, "vector<u8>">;
export declare const SenderSignedTransaction: import("@iota/bcs").BcsStruct<{
    intentMessage: import("@iota/bcs").BcsStruct<{
        intent: import("@iota/bcs").BcsStruct<{
            scope: import("@iota/bcs").BcsEnum<{
                TransactionData: null;
                TransactionEffects: null;
                CheckpointSummary: null;
                PersonalMessage: null;
            }, "IntentScope">;
            version: import("@iota/bcs").BcsEnum<{
                V0: null;
            }, "IntentVersion">;
            appId: import("@iota/bcs").BcsEnum<{
                Iota: null;
            }, "AppId">;
        }, string>;
        value: import("@iota/bcs").BcsEnum<{
            V1: import("@iota/bcs").BcsStruct<{
                kind: import("@iota/bcs").BcsEnum<{
                    ProgrammableTransaction: import("@iota/bcs").BcsStruct<{
                        inputs: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
                            Pure: {
                                bytes: string;
                            };
                            Object: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                ImmOrOwnedObject: {
                                    objectId: string;
                                    version: string;
                                    digest: string;
                                };
                                SharedObject: {
                                    objectId: string;
                                    initialSharedVersion: string;
                                    mutable: boolean;
                                };
                                Receiving: {
                                    objectId: string;
                                    version: string;
                                    digest: string;
                                };
                            }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
                        }, "Pure" | "Object">[], Iterable<import("@iota/bcs").EnumInputShape<{
                            Pure: {
                                bytes: string | Uint8Array;
                            };
                            Object: import("@iota/bcs").EnumInputShape<{
                                ImmOrOwnedObject: {
                                    objectId: string | Uint8Array;
                                    version: string | number | bigint;
                                    digest: string;
                                };
                                SharedObject: {
                                    objectId: string | Uint8Array;
                                    initialSharedVersion: string | number | bigint;
                                    mutable: boolean;
                                };
                                Receiving: {
                                    objectId: string | Uint8Array;
                                    version: string | number | bigint;
                                    digest: string;
                                };
                            }>;
                        }>> & {
                            length: number;
                        }, string>;
                        commands: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
                            MoveCall: {
                                package: string;
                                module: string;
                                function: string;
                                typeArguments: string[];
                                arguments: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                            };
                            TransferObjects: {
                                objects: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                                address: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                            };
                            SplitCoins: {
                                coin: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                                amounts: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                            };
                            MergeCoins: {
                                destination: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                                sources: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                            };
                            Publish: {
                                modules: string[];
                                dependencies: string[];
                            };
                            MakeMoveVec: {
                                type: string | null;
                                elements: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                            };
                            Upgrade: {
                                modules: string[];
                                dependencies: string[];
                                package: string;
                                ticket: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                            };
                        }, "MoveCall" | "TransferObjects" | "SplitCoins" | "MergeCoins" | "Publish" | "MakeMoveVec" | "Upgrade">[], Iterable<import("@iota/bcs").EnumInputShape<{
                            MoveCall: {
                                package: string | Uint8Array;
                                module: string;
                                function: string;
                                typeArguments: Iterable<string | TypeTagType> & {
                                    length: number;
                                };
                                arguments: Iterable<import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>> & {
                                    length: number;
                                };
                            };
                            TransferObjects: {
                                objects: Iterable<import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>> & {
                                    length: number;
                                };
                                address: import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>;
                            };
                            SplitCoins: {
                                coin: import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>;
                                amounts: Iterable<import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>> & {
                                    length: number;
                                };
                            };
                            MergeCoins: {
                                destination: import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>;
                                sources: Iterable<import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>> & {
                                    length: number;
                                };
                            };
                            Publish: {
                                modules: Iterable<string | Uint8Array> & {
                                    length: number;
                                };
                                dependencies: Iterable<string | Uint8Array> & {
                                    length: number;
                                };
                            };
                            MakeMoveVec: {
                                type: string | null;
                                elements: Iterable<import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>> & {
                                    length: number;
                                };
                            };
                            Upgrade: {
                                modules: Iterable<string | Uint8Array> & {
                                    length: number;
                                };
                                dependencies: Iterable<string | Uint8Array> & {
                                    length: number;
                                };
                                package: string | Uint8Array;
                                ticket: import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>;
                            };
                        }>> & {
                            length: number;
                        }, string>;
                    }, string>;
                    ChangeEpoch: null;
                    Genesis: null;
                    ConsensusCommitPrologue: null;
                }, "TransactionKind">;
                sender: BcsType<string, string | Uint8Array, "bytes[32]">;
                gasData: import("@iota/bcs").BcsStruct<{
                    payment: BcsType<{
                        objectId: string;
                        version: string;
                        digest: string;
                    }[], Iterable<{
                        objectId: string | Uint8Array;
                        version: string | number | bigint;
                        digest: string;
                    }> & {
                        length: number;
                    }, string>;
                    owner: BcsType<string, string | Uint8Array, "bytes[32]">;
                    price: BcsType<string, string | number | bigint, "u64">;
                    budget: BcsType<string, string | number | bigint, "u64">;
                }, string>;
                expiration: import("@iota/bcs").BcsEnum<{
                    None: null;
                    Epoch: BcsType<number, string | number, "u64">;
                }, "TransactionExpiration">;
            }, string>;
        }, "TransactionData">;
    }, string>;
    txSignatures: BcsType<string[], Iterable<string | Uint8Array> & {
        length: number;
    }, string>;
}, string>;
export declare const SenderSignedData: BcsType<{
    intentMessage: {
        intent: {
            scope: import("@iota/bcs").EnumOutputShapeWithKeys<{
                TransactionData: true;
                TransactionEffects: true;
                CheckpointSummary: true;
                PersonalMessage: true;
            }, "TransactionData" | "TransactionEffects" | "CheckpointSummary" | "PersonalMessage">;
            version: {
                V0: true;
                $kind: "V0";
            };
            appId: {
                Iota: true;
                $kind: "Iota";
            };
        };
        value: {
            V1: {
                kind: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    ProgrammableTransaction: {
                        inputs: import("@iota/bcs").EnumOutputShapeWithKeys<{
                            Pure: {
                                bytes: string;
                            };
                            Object: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                ImmOrOwnedObject: {
                                    objectId: string;
                                    version: string;
                                    digest: string;
                                };
                                SharedObject: {
                                    objectId: string;
                                    initialSharedVersion: string;
                                    mutable: boolean;
                                };
                                Receiving: {
                                    objectId: string;
                                    version: string;
                                    digest: string;
                                };
                            }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
                        }, "Pure" | "Object">[];
                        commands: import("@iota/bcs").EnumOutputShapeWithKeys<{
                            MoveCall: {
                                package: string;
                                module: string;
                                function: string;
                                typeArguments: string[];
                                arguments: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                            };
                            TransferObjects: {
                                objects: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                                address: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                            };
                            SplitCoins: {
                                coin: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                                amounts: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                            };
                            MergeCoins: {
                                destination: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                                sources: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                            };
                            Publish: {
                                modules: string[];
                                dependencies: string[];
                            };
                            MakeMoveVec: {
                                type: string | null;
                                elements: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">[];
                            };
                            Upgrade: {
                                modules: string[];
                                dependencies: string[];
                                package: string;
                                ticket: import("@iota/bcs").EnumOutputShapeWithKeys<{
                                    GasCoin: true;
                                    Input: number;
                                    Result: number;
                                    NestedResult: [number, number];
                                }, "GasCoin" | "Input" | "Result" | "NestedResult">;
                            };
                        }, "MoveCall" | "TransferObjects" | "SplitCoins" | "MergeCoins" | "Publish" | "MakeMoveVec" | "Upgrade">[];
                    };
                    ChangeEpoch: true;
                    Genesis: true;
                    ConsensusCommitPrologue: true;
                }, "ProgrammableTransaction" | "ChangeEpoch" | "Genesis" | "ConsensusCommitPrologue">;
                sender: string;
                gasData: {
                    payment: {
                        objectId: string;
                        version: string;
                        digest: string;
                    }[];
                    owner: string;
                    price: string;
                    budget: string;
                };
                expiration: import("@iota/bcs").EnumOutputShapeWithKeys<{
                    None: true;
                    Epoch: number;
                }, "None" | "Epoch">;
            };
            $kind: "V1";
        };
    };
    txSignatures: string[];
}[], Iterable<{
    intentMessage: {
        intent: {
            scope: import("@iota/bcs").EnumInputShape<{
                TransactionData: boolean | object | null;
                TransactionEffects: boolean | object | null;
                CheckpointSummary: boolean | object | null;
                PersonalMessage: boolean | object | null;
            }>;
            version: {
                V0: boolean | object | null;
            };
            appId: {
                Iota: boolean | object | null;
            };
        };
        value: {
            V1: {
                kind: import("@iota/bcs").EnumInputShape<{
                    ProgrammableTransaction: {
                        inputs: Iterable<import("@iota/bcs").EnumInputShape<{
                            Pure: {
                                bytes: string | Uint8Array;
                            };
                            Object: import("@iota/bcs").EnumInputShape<{
                                ImmOrOwnedObject: {
                                    objectId: string | Uint8Array;
                                    version: string | number | bigint;
                                    digest: string;
                                };
                                SharedObject: {
                                    objectId: string | Uint8Array;
                                    initialSharedVersion: string | number | bigint;
                                    mutable: boolean;
                                };
                                Receiving: {
                                    objectId: string | Uint8Array;
                                    version: string | number | bigint;
                                    digest: string;
                                };
                            }>;
                        }>> & {
                            length: number;
                        };
                        commands: Iterable<import("@iota/bcs").EnumInputShape<{
                            MoveCall: {
                                package: string | Uint8Array;
                                module: string;
                                function: string;
                                typeArguments: Iterable<string | TypeTagType> & {
                                    length: number;
                                };
                                arguments: Iterable<import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>> & {
                                    length: number;
                                };
                            };
                            TransferObjects: {
                                objects: Iterable<import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>> & {
                                    length: number;
                                };
                                address: import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>;
                            };
                            SplitCoins: {
                                coin: import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>;
                                amounts: Iterable<import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>> & {
                                    length: number;
                                };
                            };
                            MergeCoins: {
                                destination: import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>;
                                sources: Iterable<import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>> & {
                                    length: number;
                                };
                            };
                            Publish: {
                                modules: Iterable<string | Uint8Array> & {
                                    length: number;
                                };
                                dependencies: Iterable<string | Uint8Array> & {
                                    length: number;
                                };
                            };
                            MakeMoveVec: {
                                type: string | null;
                                elements: Iterable<import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>> & {
                                    length: number;
                                };
                            };
                            Upgrade: {
                                modules: Iterable<string | Uint8Array> & {
                                    length: number;
                                };
                                dependencies: Iterable<string | Uint8Array> & {
                                    length: number;
                                };
                                package: string | Uint8Array;
                                ticket: import("@iota/bcs").EnumInputShape<{
                                    GasCoin: boolean | object | null;
                                    Input: number;
                                    Result: number;
                                    NestedResult: readonly [number, number];
                                }>;
                            };
                        }>> & {
                            length: number;
                        };
                    };
                    ChangeEpoch: boolean | object | null;
                    Genesis: boolean | object | null;
                    ConsensusCommitPrologue: boolean | object | null;
                }>;
                sender: string | Uint8Array;
                gasData: {
                    payment: Iterable<{
                        objectId: string | Uint8Array;
                        version: string | number | bigint;
                        digest: string;
                    }> & {
                        length: number;
                    };
                    owner: string | Uint8Array;
                    price: string | number | bigint;
                    budget: string | number | bigint;
                };
                expiration: import("@iota/bcs").EnumInputShape<{
                    None: boolean | object | null;
                    Epoch: string | number;
                }>;
            };
        };
    };
    txSignatures: Iterable<string | Uint8Array> & {
        length: number;
    };
}> & {
    length: number;
}, "SenderSignedData">;
export declare const PasskeyAuthenticator: import("@iota/bcs").BcsStruct<{
    authenticatorData: BcsType<Uint8Array, Iterable<number>, "vector<u8>">;
    clientDataJson: BcsType<string, string, string>;
    userSignature: BcsType<Uint8Array, Iterable<number>, "vector<u8>">;
}, string>;
/**
 * @experimental
 * MoveAuthenticator allows authenticating transactions via a Move function call
 * as part of Account Abstraction.
 * The enum wrapper matches the Rust `MoveAuthenticatorInner` enum, which adds a
 * one-byte variant prefix to the BCS representation.
 */
export declare const MoveAuthenticator: import("@iota/bcs").BcsEnum<{
    V1: import("@iota/bcs").BcsStruct<{
        callArgs: BcsType<import("@iota/bcs").EnumOutputShapeWithKeys<{
            Pure: {
                bytes: string;
            };
            Object: import("@iota/bcs").EnumOutputShapeWithKeys<{
                ImmOrOwnedObject: {
                    objectId: string;
                    version: string;
                    digest: string;
                };
                SharedObject: {
                    objectId: string;
                    initialSharedVersion: string;
                    mutable: boolean;
                };
                Receiving: {
                    objectId: string;
                    version: string;
                    digest: string;
                };
            }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
        }, "Pure" | "Object">[], Iterable<import("@iota/bcs").EnumInputShape<{
            Pure: {
                bytes: string | Uint8Array;
            };
            Object: import("@iota/bcs").EnumInputShape<{
                ImmOrOwnedObject: {
                    objectId: string | Uint8Array;
                    version: string | number | bigint;
                    digest: string;
                };
                SharedObject: {
                    objectId: string | Uint8Array;
                    initialSharedVersion: string | number | bigint;
                    mutable: boolean;
                };
                Receiving: {
                    objectId: string | Uint8Array;
                    version: string | number | bigint;
                    digest: string;
                };
            }>;
        }>> & {
            length: number;
        }, string>;
        typeArgs: BcsType<string[], Iterable<string | TypeTagType> & {
            length: number;
        }, string>;
        objectToAuthenticate: import("@iota/bcs").BcsEnum<{
            Pure: import("@iota/bcs").BcsStruct<{
                bytes: BcsType<string, string | Uint8Array, string>;
            }, string>;
            Object: import("@iota/bcs").BcsEnum<{
                ImmOrOwnedObject: import("@iota/bcs").BcsStruct<{
                    objectId: BcsType<string, string | Uint8Array, "bytes[32]">;
                    version: BcsType<string, string | number | bigint, "u64">;
                    digest: BcsType<string, string, "ObjectDigest">;
                }, string>;
                SharedObject: import("@iota/bcs").BcsStruct<{
                    objectId: BcsType<string, string | Uint8Array, "bytes[32]">;
                    initialSharedVersion: BcsType<string, string | number | bigint, "u64">;
                    mutable: BcsType<boolean, boolean, "bool">;
                }, string>;
                Receiving: import("@iota/bcs").BcsStruct<{
                    objectId: BcsType<string, string | Uint8Array, "bytes[32]">;
                    version: BcsType<string, string | number | bigint, "u64">;
                    digest: BcsType<string, string, "ObjectDigest">;
                }, string>;
            }, "ObjectArg">;
        }, "CallArg">;
    }, string>;
}, "MoveAuthenticator">;
//# sourceMappingURL=bcs.d.ts.map