@mysten/sui/dist/esm/transactions/data/internal.d.ts

Sui TypeScript API(Work in Progress)

import type { EnumInputShape, EnumOutputShape } from '@mysten/bcs';
import type { BaseSchema, Input, Output } from 'valibot';
type Merge<T> = T extends object ? {
    [K in keyof T]: T[K];
} : never;
type EnumSchema<T extends Record<string, BaseSchema<any>>> = BaseSchema<EnumInputShape<Merge<{
    [K in keyof T]: Input<T[K]>;
}>>, EnumOutputShape<Merge<{
    [K in keyof T]: Output<T[K]>;
}>>>;
export declare function safeEnum<T extends Record<string, BaseSchema<any>>>(options: T): EnumSchema<T>;
export declare const SuiAddress: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
export declare const ObjectID: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
export declare const BCSBytes: import("valibot").StringSchema<string>;
export declare const JsonU64: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
export declare const ObjectRef: import("valibot").ObjectSchema<{
    objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
    version: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
    digest: import("valibot").StringSchema<string>;
}, undefined, {
    objectId: string;
    version: string | number;
    digest: string;
}>;
export type ObjectRef = Output<typeof ObjectRef>;
export declare const Argument: BaseSchema<{
    GasCoin: true;
} | {
    Input: number;
    type?: "object" | "pure" | undefined;
} | {
    Result: number;
} | {
    NestedResult: [number, number];
}, {
    $kind: 'GasCoin';
    GasCoin: true;
} | {
    $kind: 'Input';
    Input: number;
    type?: "pure" | undefined;
} | {
    $kind: 'Input';
    Input: number;
    type?: "object" | undefined;
} | {
    $kind: 'Result';
    Result: number;
} | {
    $kind: 'NestedResult';
    NestedResult: [number, number];
}>;
export type Argument = Output<typeof Argument>;
export declare const GasData: import("valibot").ObjectSchema<{
    budget: import("valibot").NullableSchema<import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>, undefined, string | number | null>;
    price: import("valibot").NullableSchema<import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>, undefined, string | number | null>;
    owner: import("valibot").NullableSchema<import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>, undefined, string | null>;
    payment: import("valibot").NullableSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
        objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
        version: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
        digest: import("valibot").StringSchema<string>;
    }, undefined, {
        objectId: string;
        version: string | number;
        digest: string;
    }>, {
        objectId: string;
        version: string | number;
        digest: string;
    }[]>, undefined, {
        objectId: string;
        version: string | number;
        digest: string;
    }[] | null>;
}, undefined, {
    payment: {
        objectId: string;
        version: string | number;
        digest: string;
    }[] | null;
    owner: string | null;
    price: string | number | null;
    budget: string | number | null;
}>;
export type GasData = Output<typeof GasData>;
export declare const StructTag: import("valibot").ObjectSchema<{
    address: import("valibot").StringSchema<string>;
    module: import("valibot").StringSchema<string>;
    name: import("valibot").StringSchema<string>;
    typeParams: import("valibot").ArraySchema<import("valibot").StringSchema<string>, string[]>;
}, undefined, {
    address: string;
    module: string;
    name: string;
    typeParams: string[];
}>;
export type StructTag = Output<typeof StructTag>;
export type OpenMoveTypeSignatureBody = 'address' | 'bool' | 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'u256' | {
    vector: OpenMoveTypeSignatureBody;
} | {
    datatype: {
        package: string;
        module: string;
        type: string;
        typeParameters: OpenMoveTypeSignatureBody[];
    };
} | {
    typeParameter: number;
};
export declare const OpenMoveTypeSignatureBody: BaseSchema<OpenMoveTypeSignatureBody>;
export declare const OpenMoveTypeSignature: import("valibot").ObjectSchema<{
    ref: import("valibot").NullableSchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"&", "&"> | import("valibot").LiteralSchema<"&mut", "&mut">)[], "&" | "&mut">, undefined, "&" | "&mut" | null>;
    body: BaseSchema<OpenMoveTypeSignatureBody>;
}, undefined, {
    ref: "&" | "&mut" | null;
    body: OpenMoveTypeSignatureBody;
}>;
export type OpenMoveTypeSignature = Output<typeof OpenMoveTypeSignature>;
declare const ProgrammableMoveCall: import("valibot").ObjectSchema<{
    package: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
    module: import("valibot").StringSchema<string>;
    function: import("valibot").StringSchema<string>;
    typeArguments: import("valibot").ArraySchema<import("valibot").StringSchema<string>, string[]>;
    arguments: import("valibot").ArraySchema<BaseSchema<{
        GasCoin: true;
    } | {
        Input: number;
        type?: "object" | "pure" | undefined;
    } | {
        Result: number;
    } | {
        NestedResult: [number, number];
    }, {
        $kind: 'GasCoin';
        GasCoin: true;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "pure" | undefined;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "object" | undefined;
    } | {
        $kind: 'Result';
        Result: number;
    } | {
        $kind: 'NestedResult';
        NestedResult: [number, number];
    }>, ({
        $kind: 'GasCoin';
        GasCoin: true;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "pure" | undefined;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "object" | undefined;
    } | {
        $kind: 'Result';
        Result: number;
    } | {
        $kind: 'NestedResult';
        NestedResult: [number, number];
    })[]>;
    _argumentTypes: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
        ref: import("valibot").NullableSchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"&", "&"> | import("valibot").LiteralSchema<"&mut", "&mut">)[], "&" | "&mut">, undefined, "&" | "&mut" | null>;
        body: BaseSchema<OpenMoveTypeSignatureBody>;
    }, undefined, {
        ref: "&" | "&mut" | null;
        body: OpenMoveTypeSignatureBody;
    }>, {
        ref: "&" | "&mut" | null;
        body: OpenMoveTypeSignatureBody;
    }[]>, undefined, {
        ref: "&" | "&mut" | null;
        body: OpenMoveTypeSignatureBody;
    }[] | null>, undefined, {
        ref: "&" | "&mut" | null;
        body: OpenMoveTypeSignatureBody;
    }[] | null | undefined>;
}, undefined, {
    function: string;
    module: string;
    package: string;
    typeArguments: string[];
    arguments: ({
        $kind: 'GasCoin';
        GasCoin: true;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "pure" | undefined;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "object" | undefined;
    } | {
        $kind: 'Result';
        Result: number;
    } | {
        $kind: 'NestedResult';
        NestedResult: [number, number];
    })[];
    _argumentTypes?: {
        ref: "&" | "&mut" | null;
        body: OpenMoveTypeSignatureBody;
    }[] | null | undefined;
}>;
export type ProgrammableMoveCall = Output<typeof ProgrammableMoveCall>;
export declare const $Intent: import("valibot").ObjectSchema<{
    name: import("valibot").StringSchema<string>;
    inputs: import("valibot").RecordSchema<import("valibot").StringSchema<string>, import("valibot").UnionSchema<(BaseSchema<{
        GasCoin: true;
    } | {
        Input: number;
        type?: "object" | "pure" | undefined;
    } | {
        Result: number;
    } | {
        NestedResult: [number, number];
    }, {
        $kind: 'GasCoin';
        GasCoin: true;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "pure" | undefined;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "object" | undefined;
    } | {
        $kind: 'Result';
        Result: number;
    } | {
        $kind: 'NestedResult';
        NestedResult: [number, number];
    }> | import("valibot").ArraySchema<BaseSchema<{
        GasCoin: true;
    } | {
        Input: number;
        type?: "object" | "pure" | undefined;
    } | {
        Result: number;
    } | {
        NestedResult: [number, number];
    }, {
        $kind: 'GasCoin';
        GasCoin: true;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "pure" | undefined;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "object" | undefined;
    } | {
        $kind: 'Result';
        Result: number;
    } | {
        $kind: 'NestedResult';
        NestedResult: [number, number];
    }>, ({
        $kind: 'GasCoin';
        GasCoin: true;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "pure" | undefined;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "object" | undefined;
    } | {
        $kind: 'Result';
        Result: number;
    } | {
        $kind: 'NestedResult';
        NestedResult: [number, number];
    })[]>)[], {
        $kind: 'GasCoin';
        GasCoin: true;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "pure" | undefined;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "object" | undefined;
    } | {
        $kind: 'Result';
        Result: number;
    } | {
        $kind: 'NestedResult';
        NestedResult: [number, number];
    } | ({
        $kind: 'GasCoin';
        GasCoin: true;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "pure" | undefined;
    } | {
        $kind: 'Input';
        Input: number;
        type?: "object" | undefined;
    } | {
        $kind: 'Result';
        Result: number;
    } | {
        $kind: 'NestedResult';
        NestedResult: [number, number];
    })[]>, {
        [x: string]: {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        } | ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[];
    }>;
    data: import("valibot").RecordSchema<import("valibot").StringSchema<string>, import("valibot").UnknownSchema<unknown>, {
        [x: string]: unknown;
    }>;
}, undefined, {
    name: string;
    inputs: {
        [x: string]: {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        } | ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[];
    };
    data: {
        [x: string]: unknown;
    };
}>;
export declare const Command: EnumSchema<{
    MoveCall: import("valibot").ObjectSchema<{
        package: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
        module: import("valibot").StringSchema<string>;
        function: import("valibot").StringSchema<string>;
        typeArguments: import("valibot").ArraySchema<import("valibot").StringSchema<string>, string[]>;
        arguments: import("valibot").ArraySchema<BaseSchema<{
            GasCoin: true;
        } | {
            Input: number;
            type?: "object" | "pure" | undefined;
        } | {
            Result: number;
        } | {
            NestedResult: [number, number];
        }, {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        }>, ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[]>;
        _argumentTypes: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
            ref: import("valibot").NullableSchema<import("valibot").UnionSchema<(import("valibot").LiteralSchema<"&", "&"> | import("valibot").LiteralSchema<"&mut", "&mut">)[], "&" | "&mut">, undefined, "&" | "&mut" | null>;
            body: BaseSchema<OpenMoveTypeSignatureBody>;
        }, undefined, {
            ref: "&" | "&mut" | null;
            body: OpenMoveTypeSignatureBody;
        }>, {
            ref: "&" | "&mut" | null;
            body: OpenMoveTypeSignatureBody;
        }[]>, undefined, {
            ref: "&" | "&mut" | null;
            body: OpenMoveTypeSignatureBody;
        }[] | null>, undefined, {
            ref: "&" | "&mut" | null;
            body: OpenMoveTypeSignatureBody;
        }[] | null | undefined>;
    }, undefined, {
        function: string;
        module: string;
        package: string;
        typeArguments: string[];
        arguments: ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[];
        _argumentTypes?: {
            ref: "&" | "&mut" | null;
            body: OpenMoveTypeSignatureBody;
        }[] | null | undefined;
    }>;
    TransferObjects: import("valibot").ObjectSchema<{
        objects: import("valibot").ArraySchema<BaseSchema<{
            GasCoin: true;
        } | {
            Input: number;
            type?: "object" | "pure" | undefined;
        } | {
            Result: number;
        } | {
            NestedResult: [number, number];
        }, {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        }>, ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[]>;
        address: BaseSchema<{
            GasCoin: true;
        } | {
            Input: number;
            type?: "object" | "pure" | undefined;
        } | {
            Result: number;
        } | {
            NestedResult: [number, number];
        }, {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        }>;
    }, undefined, {
        address: {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        };
        objects: ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[];
    }>;
    SplitCoins: import("valibot").ObjectSchema<{
        coin: BaseSchema<{
            GasCoin: true;
        } | {
            Input: number;
            type?: "object" | "pure" | undefined;
        } | {
            Result: number;
        } | {
            NestedResult: [number, number];
        }, {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        }>;
        amounts: import("valibot").ArraySchema<BaseSchema<{
            GasCoin: true;
        } | {
            Input: number;
            type?: "object" | "pure" | undefined;
        } | {
            Result: number;
        } | {
            NestedResult: [number, number];
        }, {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        }>, ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[]>;
    }, undefined, {
        coin: {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        };
        amounts: ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[];
    }>;
    MergeCoins: import("valibot").ObjectSchema<{
        destination: BaseSchema<{
            GasCoin: true;
        } | {
            Input: number;
            type?: "object" | "pure" | undefined;
        } | {
            Result: number;
        } | {
            NestedResult: [number, number];
        }, {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        }>;
        sources: import("valibot").ArraySchema<BaseSchema<{
            GasCoin: true;
        } | {
            Input: number;
            type?: "object" | "pure" | undefined;
        } | {
            Result: number;
        } | {
            NestedResult: [number, number];
        }, {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        }>, ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[]>;
    }, undefined, {
        destination: {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        };
        sources: ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[];
    }>;
    Publish: import("valibot").ObjectSchema<{
        modules: import("valibot").ArraySchema<import("valibot").StringSchema<string>, string[]>;
        dependencies: import("valibot").ArraySchema<import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>, string[]>;
    }, undefined, {
        modules: string[];
        dependencies: string[];
    }>;
    MakeMoveVec: import("valibot").ObjectSchema<{
        type: import("valibot").NullableSchema<import("valibot").StringSchema<string>, undefined, string | null>;
        elements: import("valibot").ArraySchema<BaseSchema<{
            GasCoin: true;
        } | {
            Input: number;
            type?: "object" | "pure" | undefined;
        } | {
            Result: number;
        } | {
            NestedResult: [number, number];
        }, {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        }>, ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[]>;
    }, undefined, {
        type: string | null;
        elements: ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[];
    }>;
    Upgrade: import("valibot").ObjectSchema<{
        modules: import("valibot").ArraySchema<import("valibot").StringSchema<string>, string[]>;
        dependencies: import("valibot").ArraySchema<import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>, string[]>;
        package: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
        ticket: BaseSchema<{
            GasCoin: true;
        } | {
            Input: number;
            type?: "object" | "pure" | undefined;
        } | {
            Result: number;
        } | {
            NestedResult: [number, number];
        }, {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        }>;
    }, undefined, {
        package: string;
        modules: string[];
        dependencies: string[];
        ticket: {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        };
    }>;
    $Intent: import("valibot").ObjectSchema<{
        name: import("valibot").StringSchema<string>;
        inputs: import("valibot").RecordSchema<import("valibot").StringSchema<string>, import("valibot").UnionSchema<(BaseSchema<{
            GasCoin: true;
        } | {
            Input: number;
            type?: "object" | "pure" | undefined;
        } | {
            Result: number;
        } | {
            NestedResult: [number, number];
        }, {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        }> | import("valibot").ArraySchema<BaseSchema<{
            GasCoin: true;
        } | {
            Input: number;
            type?: "object" | "pure" | undefined;
        } | {
            Result: number;
        } | {
            NestedResult: [number, number];
        }, {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        }>, ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[]>)[], {
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        } | ({
            $kind: 'GasCoin';
            GasCoin: true;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "pure" | undefined;
        } | {
            $kind: 'Input';
            Input: number;
            type?: "object" | undefined;
        } | {
            $kind: 'Result';
            Result: number;
        } | {
            $kind: 'NestedResult';
            NestedResult: [number, number];
        })[]>, {
            [x: string]: {
                $kind: 'GasCoin';
                GasCoin: true;
            } | {
                $kind: 'Input';
                Input: number;
                type?: "pure" | undefined;
            } | {
                $kind: 'Input';
                Input: number;
                type?: "object" | undefined;
            } | {
                $kind: 'Result';
                Result: number;
            } | {
                $kind: 'NestedResult';
                NestedResult: [number, number];
            } | ({
                $kind: 'GasCoin';
                GasCoin: true;
            } | {
                $kind: 'Input';
                Input: number;
                type?: "pure" | undefined;
            } | {
                $kind: 'Input';
                Input: number;
                type?: "object" | undefined;
            } | {
                $kind: 'Result';
                Result: number;
            } | {
                $kind: 'NestedResult';
                NestedResult: [number, number];
            })[];
        }>;
        data: import("valibot").RecordSchema<import("valibot").StringSchema<string>, import("valibot").UnknownSchema<unknown>, {
            [x: string]: unknown;
        }>;
    }, undefined, {
        name: string;
        inputs: {
            [x: string]: {
                $kind: 'GasCoin';
                GasCoin: true;
            } | {
                $kind: 'Input';
                Input: number;
                type?: "pure" | undefined;
            } | {
                $kind: 'Input';
                Input: number;
                type?: "object" | undefined;
            } | {
                $kind: 'Result';
                Result: number;
            } | {
                $kind: 'NestedResult';
                NestedResult: [number, number];
            } | ({
                $kind: 'GasCoin';
                GasCoin: true;
            } | {
                $kind: 'Input';
                Input: number;
                type?: "pure" | undefined;
            } | {
                $kind: 'Input';
                Input: number;
                type?: "object" | undefined;
            } | {
                $kind: 'Result';
                Result: number;
            } | {
                $kind: 'NestedResult';
                NestedResult: [number, number];
            })[];
        };
        data: {
            [x: string]: unknown;
        };
    }>;
}>;
export type Command<Arg = Argument> = EnumOutputShape<{
    MoveCall: {
        package: string;
        module: string;
        function: string;
        typeArguments: string[];
        arguments: Arg[];
        _argumentTypes?: OpenMoveTypeSignature[] | null;
    };
    TransferObjects: {
        objects: Arg[];
        address: Arg;
    };
    SplitCoins: {
        coin: Arg;
        amounts: Arg[];
    };
    MergeCoins: {
        destination: Arg;
        sources: Arg[];
    };
    Publish: {
        modules: string[];
        dependencies: string[];
    };
    MakeMoveVec: {
        type: string | null;
        elements: Arg[];
    };
    Upgrade: {
        modules: string[];
        dependencies: string[];
        package: string;
        ticket: Arg;
    };
    $Intent: {
        name: string;
        inputs: Record<string, Argument | Argument[]>;
        data: Record<string, unknown>;
    };
}>;
export declare const ObjectArg: EnumSchema<{
    ImmOrOwnedObject: import("valibot").ObjectSchema<{
        objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
        version: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
        digest: import("valibot").StringSchema<string>;
    }, undefined, {
        objectId: string;
        version: string | number;
        digest: string;
    }>;
    SharedObject: import("valibot").ObjectSchema<{
        objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
        initialSharedVersion: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
        mutable: import("valibot").BooleanSchema<boolean>;
    }, undefined, {
        objectId: string;
        initialSharedVersion: string | number;
        mutable: boolean;
    }>;
    Receiving: import("valibot").ObjectSchema<{
        objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
        version: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
        digest: import("valibot").StringSchema<string>;
    }, undefined, {
        objectId: string;
        version: string | number;
        digest: string;
    }>;
}>;
declare const CallArg: EnumSchema<{
    Object: EnumSchema<{
        ImmOrOwnedObject: import("valibot").ObjectSchema<{
            objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
            version: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
            digest: import("valibot").StringSchema<string>;
        }, undefined, {
            objectId: string;
            version: string | number;
            digest: string;
        }>;
        SharedObject: import("valibot").ObjectSchema<{
            objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
            initialSharedVersion: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
            mutable: import("valibot").BooleanSchema<boolean>;
        }, undefined, {
            objectId: string;
            initialSharedVersion: string | number;
            mutable: boolean;
        }>;
        Receiving: import("valibot").ObjectSchema<{
            objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
            version: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
            digest: import("valibot").StringSchema<string>;
        }, undefined, {
            objectId: string;
            version: string | number;
            digest: string;
        }>;
    }>;
    Pure: import("valibot").ObjectSchema<{
        bytes: import("valibot").StringSchema<string>;
    }, undefined, {
        bytes: string;
    }>;
    UnresolvedPure: import("valibot").ObjectSchema<{
        value: import("valibot").UnknownSchema<unknown>;
    }, undefined, {
        value: unknown;
    }>;
    UnresolvedObject: import("valibot").ObjectSchema<{
        objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
        version: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>, undefined, string | number | null>, undefined, string | number | null | undefined>;
        digest: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<string>, undefined, string | null>, undefined, string | null | undefined>;
        initialSharedVersion: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>, undefined, string | number | null>, undefined, string | number | null | undefined>;
    }, undefined, {
        objectId: string;
        version?: string | number | null | undefined;
        digest?: string | null | undefined;
        initialSharedVersion?: string | number | null | undefined;
    }>;
}>;
export type CallArg = Output<typeof CallArg>;
export declare const NormalizedCallArg: EnumSchema<{
    Object: EnumSchema<{
        ImmOrOwnedObject: import("valibot").ObjectSchema<{
            objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
            version: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
            digest: import("valibot").StringSchema<string>;
        }, undefined, {
            objectId: string;
            version: string | number;
            digest: string;
        }>;
        SharedObject: import("valibot").ObjectSchema<{
            objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
            initialSharedVersion: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
            mutable: import("valibot").BooleanSchema<boolean>;
        }, undefined, {
            objectId: string;
            initialSharedVersion: string | number;
            mutable: boolean;
        }>;
        Receiving: import("valibot").ObjectSchema<{
            objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
            version: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
            digest: import("valibot").StringSchema<string>;
        }, undefined, {
            objectId: string;
            version: string | number;
            digest: string;
        }>;
    }>;
    Pure: import("valibot").ObjectSchema<{
        bytes: import("valibot").StringSchema<string>;
    }, undefined, {
        bytes: string;
    }>;
}>;
export declare const TransactionExpiration: EnumSchema<{
    None: import("valibot").LiteralSchema<true, true>;
    Epoch: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
}>;
export type TransactionExpiration = Output<typeof TransactionExpiration>;
export declare const TransactionData: import("valibot").ObjectSchema<{
    version: import("valibot").LiteralSchema<2, 2>;
    sender: import("valibot").NullishSchema<import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>, undefined, string | null | undefined>;
    expiration: import("valibot").NullishSchema<EnumSchema<{
        None: import("valibot").LiteralSchema<true, true>;
        Epoch: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
    }>, undefined, import("@mysten/bcs").EnumOutputShapeWithKeys<{
        None: true;
        Epoch: string | number;
    }, "None" | "Epoch"> | null | undefined>;
    gasData: import("valibot").ObjectSchema<{
        budget: import("valibot").NullableSchema<import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>, undefined, string | number | null>;
        price: import("valibot").NullableSchema<import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>, undefined, string | number | null>;
        owner: import("valibot").NullableSchema<import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>, undefined, string | null>;
        payment: import("valibot").NullableSchema<import("valibot").ArraySchema<import("valibot").ObjectSchema<{
            objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
            version: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
            digest: import("valibot").StringSchema<string>;
        }, undefined, {
            objectId: string;
            version: string | number;
            digest: string;
        }>, {
            objectId: string;
            version: string | number;
            digest: string;
        }[]>, undefined, {
            objectId: string;
            version: string | number;
            digest: string;
        }[] | null>;
    }, undefined, {
        payment: {
            objectId: string;
            version: string | number;
            digest: string;
        }[] | null;
        owner: string | null;
        price: string | number | null;
        budget: string | number | null;
    }>;
    inputs: import("valibot").ArraySchema<EnumSchema<{
        Object: EnumSchema<{
            ImmOrOwnedObject: import("valibot").ObjectSchema<{
                objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
                version: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
                digest: import("valibot").StringSchema<string>;
            }, undefined, {
                objectId: string;
                version: string | number;
                digest: string;
            }>;
            SharedObject: import("valibot").ObjectSchema<{
                objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
                initialSharedVersion: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
                mutable: import("valibot").BooleanSchema<boolean>;
            }, undefined, {
                objectId: string;
                initialSharedVersion: string | number;
                mutable: boolean;
            }>;
            Receiving: import("valibot").ObjectSchema<{
                objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
                version: import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>;
                digest: import("valibot").StringSchema<string>;
            }, undefined, {
                objectId: string;
                version: string | number;
                digest: string;
            }>;
        }>;
        Pure: import("valibot").ObjectSchema<{
            bytes: import("valibot").StringSchema<string>;
        }, undefined, {
            bytes: string;
        }>;
        UnresolvedPure: import("valibot").ObjectSchema<{
            value: import("valibot").UnknownSchema<unknown>;
        }, undefined, {
            value: unknown;
        }>;
        UnresolvedObject: import("valibot").ObjectSchema<{
            objectId: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
            version: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>, undefined, string | number | null>, undefined, string | number | null | undefined>;
            digest: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").StringSchema<string>, undefined, string | null>, undefined, string | null | undefined>;
            initialSharedVersion: import("valibot").OptionalSchema<import("valibot").NullableSchema<import("valibot").UnionSchema<(import("valibot").StringSchema<string> | import("valibot").NumberSchema<number>)[], string | number>, undefined, string | number | null>, undefined, string | number | null | undefined>;
        }, undefined, {
            objectId: string;
            version?: string | number | null | undefined;
            digest?: string | null | undefined;
            initialSharedVersion?: string | number | null | undefined;
        }>;
    }>, import("@mysten/bcs").EnumOutputShapeWithKeys<{
        Object: import("@mysten/bcs").EnumOutputShapeWithKeys<{
            ImmOrOwnedObject: {
                objectId: string;
                version: string | number;
                digest: string;
            };
            SharedObject: {
                objectId: string;
                initialSharedVersion: string | number;
                mutable: boolean;
            };
            Receiving: {
                objectId: string;
                version: string | number;
                digest: string;
            };
        }, "ImmOrOwnedObject" | "SharedObject" | "Receiving">;
        Pure: {
            bytes: string;
        };
        UnresolvedPure: {
            value: unknown;
        };
        UnresolvedObject: {
            objectId: string;
            version?: string | number | null | undefined;
            digest?: string | null | undefined;
            initialSharedVersion?: string | number | null | undefined;
        };
    }, "Pure" | "Object" | "UnresolvedPure" | "UnresolvedObject">[]>;
    commands: import("valibot").ArraySchema<EnumSchema<{
        MoveCall: import("valibot").ObjectSchema<{
            package: import("valibot").SchemaWithTransform<import("valibot").StringSchema<string>, string>;
            module: import("valibot").StringSchema<string>;
            function: import("valibot").StringSchema<string>;
            typeArguments: import("valibot").ArraySchema<import("valibot").StringSchema<string>, string[]>;
            arguments: import("valibot").ArraySchema<BaseSchema<{
                GasCoin: true;
            } | {
                Input: number;
                type?: "object" | "pure" | undefined;
            } | {
                Result: number;
            } | {
                NestedResult: [number, number];
            }, {
                $kind: 'GasCoin';
                GasCoin: true;
            } | {
                $kind: 'Input';
                Input: number;
                type?: "pure" | undefined;
            } | {
                $kind: 'Input';
                Input: number;
                type?: