import { CLType, CLValue, CLKeyParameters } from "casper-js-sdk";
export declare enum CEP47Events {
    Mint = "Mint",
    Burn = "Burn",
    Approval = "Approval",
    ApprovalRevoked = "ApprovalRevoked",
    ApprovalForAll = "ApprovalForAll",
    RevokedForAll = "RevokedForAll",
    Transfer = "Transfer",
    MetadataUpdated = "MetadataUpdated",
    VariablesSet = "VariablesSet",
    Migration = "Migration"
}
export interface CallConfig {
    useSessionCode: boolean;
}
export declare enum NamedKeyConventionMode {
    DerivedFromCollectionName = 0,
    V1_0Standard = 1,
    V1_0Custom = 2
}
export declare enum NFTOwnershipMode {
    Minter = 0,
    Assigned = 1,
    Transferable = 2
}
export declare enum NFTKind {
    Physical = 0,
    Digital = 1,
    Virtual = 2
}
export declare enum NFTHolderMode {
    Accounts = 0,
    Contracts = 1,
    Mixed = 2
}
export declare enum NFTMetadataKind {
    CEP78 = 0,
    NFT721 = 1,
    Raw = 2,
    CustomValidated = 3
}
export declare enum NFTIdentifierMode {
    Ordinal = 0,
    Hash = 1
}
export declare enum MetadataMutability {
    Immutable = 0,
    Mutable = 1
}
export declare enum MintingMode {
    Installer = 0,
    Public = 1,
    Acl = 2
}
export declare enum BurnMode {
    Burnable = 0,
    NonBurnable = 1
}
export declare enum WhitelistMode {
    Unlocked = 0,
    Locked = 1
}
export declare enum OwnerReverseLookupMode {
    NoLookup = 0,
    Complete = 1,
    TransfersOnly = 2
}
export declare enum EventsMode {
    NoEvents = 0,
    CEP47 = 1,
    CES = 2
}
export interface JSONSchemaEntry {
    name: string;
    description: string;
    required: boolean;
}
export interface JSONSchemaObject {
    properties: Record<string, JSONSchemaEntry>;
}
export declare type ConfigurableVariables = {
    allowMinting?: boolean;
    contractWhitelist?: string[];
};
export declare type InstallArgs = {
    collectionName: string;
    collectionSymbol: string;
    totalTokenSupply: string;
    ownershipMode: NFTOwnershipMode;
    nftKind: NFTKind;
    jsonSchema?: JSONSchemaObject;
    nftMetadataKind: NFTMetadataKind;
    identifierMode: NFTIdentifierMode;
    metadataMutability: MetadataMutability;
    mintingMode?: MintingMode;
    whitelistMode?: WhitelistMode;
    holderMode?: NFTHolderMode;
    burnMode?: BurnMode;
    ownerReverseLookupMode?: OwnerReverseLookupMode;
    namedKeyConventionMode?: NamedKeyConventionMode;
    accessKeyName?: string;
    hashKeyName?: string;
    eventsMode?: EventsMode;
} & ConfigurableVariables;
export interface RegisterArgs {
    tokenOwner: CLKeyParameters;
}
export interface MintArgs {
    owner: CLKeyParameters;
    meta: Record<string, string>;
    collectionName?: string;
}
export interface TokenArgs {
    tokenId?: string;
    tokenHash?: string;
}
export declare type BurnArgs = TokenArgs;
export declare type TransferArgs = {
    target: CLKeyParameters;
    source: CLKeyParameters;
} & TokenArgs;
export declare type TokenMetadataArgs = {
    tokenMetaData: Record<string, string>;
};
export declare type StoreBalanceOfArgs = {
    tokenOwner: CLKeyParameters;
    keyName: string;
};
export declare type StoreApprovedArgs = {
    keyName: string;
} & TokenArgs;
export declare type StoreOwnerOfArgs = StoreApprovedArgs;
export declare type ApproveArgs = {
    operator: CLKeyParameters;
} & TokenArgs;
export declare type ApproveAllArgs = {
    operator: CLKeyParameters;
    approveAll: boolean;
    tokenOwner: CLKeyParameters;
};
export declare type MigrateArgs = {
    collectionName: string;
};
declare type WriteCLValue = {
    cl_type: string;
    bytes: string;
    parsed: string;
};
declare type TransformValue = {
    WriteCLValue?: WriteCLValue;
};
export interface Transform {
    key: string;
    transform: TransformValue;
}
interface Effect {
    transforms: Transform[];
}
interface ExecutionResultBody {
    cost: number;
    error_message?: string | null;
    transfers: string[];
    effect: Effect;
}
export interface ExecutionResult {
    Success?: ExecutionResultBody;
    Failure?: ExecutionResultBody;
}
export interface WithRemainder<T> {
    data: T;
    remainder: Uint8Array;
}
export interface RawCLValue {
    clType: CLType;
    bytes: Uint8Array;
}
export interface EventItem {
    id: number;
    body: {
        DeployProcessed: {
            execution_result: ExecutionResult;
        };
    };
}
export interface EventParsed {
    name: string;
    clValue: CLValue;
}
export {};