import { Infer } from '../../utils';
import { SharedObjectRef, SuiObjectRef } from './objects';
export type ObjectArg = {
    ImmOrOwnedObject: SuiObjectRef;
} | {
    SharedObject: SharedObjectRef;
} | {
    Receiving: SuiObjectRef;
};
export type ObjectCallArg = {
    Object: ObjectArg;
};
/**
 * A pure argument.
 */
export type PureArg = {
    Pure: Array<number>;
};
export declare function isPureArg(arg: any): arg is PureArg;
/**
 * An argument for the transaction. It is a 'meant' enum which expects to have
 * one of the optional properties. If not, the BCS error will be thrown while
 * attempting to form a transaction.
 *
 * Example:
 * ```js
 * let arg1: CallArg = { Object: { Shared: {
 *   objectId: '5460cf92b5e3e7067aaace60d88324095fd22944',
 *   initialSharedVersion: 1,
 *   mutable: true,
 * } } };
 * let arg2: CallArg = { Pure: bcs.ser(BCS.STRING, 100000).toBytes() };
 * let arg3: CallArg = { Object: { ImmOrOwned: {
 *   objectId: '4047d2e25211d87922b6650233bd0503a6734279',
 *   version: 1,
 *   digest: 'bCiANCht4O9MEUhuYjdRCqRPZjr2rJ8MfqNiwyhmRgA='
 * } } };
 * ```
 *
 * For `Pure` arguments BCS is required. You must encode the values with BCS according
 * to the type required by the called function. Pure accepts only serialized values
 */
export type CallArg = PureArg | ObjectCallArg;
export declare const ObjectOwner: import("../../utils").Struct<{
    AddressOwner: string;
} | {
    ObjectOwner: string;
} | {
    Shared: {
        initial_shared_version: string | null;
    };
} | "Immutable", null>;
export type ObjectOwner = Infer<typeof ObjectOwner>;
export type SuiJsonValue = boolean | number | string | CallArg | Array<SuiJsonValue>;
export declare const SuiJsonValue: import("../../utils").Struct<SuiJsonValue, null>;
export declare const ProtocolConfig: import("../../utils").Struct<{
    attributes: Record<string, {
        u32: string;
    } | {
        u64: string;
    } | {
        f64: string;
    } | null>;
    featureFlags: Record<string, boolean>;
    maxSupportedProtocolVersion: string;
    minSupportedProtocolVersion: string;
    protocolVersion: string;
}, {
    attributes: import("../../utils").Struct<Record<string, {
        u32: string;
    } | {
        u64: string;
    } | {
        f64: string;
    } | null>, null>;
    featureFlags: import("../../utils").Struct<Record<string, boolean>, null>;
    maxSupportedProtocolVersion: import("../../utils").Struct<string, null>;
    minSupportedProtocolVersion: import("../../utils").Struct<string, null>;
    protocolVersion: import("../../utils").Struct<string, null>;
}>;
export type ProtocolConfig = Infer<typeof ProtocolConfig>;