import { JSONSchema, ValidateFunction } from '../../validation';
import { FuncKeywordDefinition, KeywordDefinition } from 'ajv';
/**
 * MappingType
 * @alpha
 */
export declare enum MappingType {
    SINGLE = "single",
    ANY = "any",
    MULTIPLE = "multiple",
    RANGE = "range"
}
/**
 * Mapping
 * @alpha
 */
export type Mapping = SingleMapping | AnyMapping | RangeMapping | MultipleMapping;
/**
 * Network
 * @alpha
 */
export declare enum ContractNetwork {
    MAINNET = "mainnet",
    BASE_MAINNET = "base_mainnet",
    BASE_SEPOLIA = "base_sepolia",
    MONAD_MAINNET = "monad_mainnet",
    MONAD_TESTNET = "monad_testnet",
    APE_MAINNET = "ape_mainnet",
    APE_CALDERA = "ape_caldera",
    MATIC = "matic",
    SEPOLIA = "sepolia",
    AMOY = "amoy"
}
/**
 * ContractAddress
 * @alpha
 */
export type ContractAddress = string;
/**
 * Mappings
 * @alpha
 */
export type Mappings = Partial<Record<ContractNetwork, Record<ContractAddress, Mapping[]>>>;
/**
 * SingleMapping
 * @alpha
 */
export type SingleMapping = {
    type: MappingType.SINGLE;
    id: string;
};
/**
 * AnyMapping
 * @alpha
 */
export type AnyMapping = {
    type: MappingType.ANY;
};
/**
 * RangeMapping
 * @alpha
 */
export type RangeMapping = {
    type: MappingType.RANGE;
    from: string;
    to: string;
};
/**
 * MultipleMapping
 * @alpha
 */
export type MultipleMapping = {
    type: MappingType.MULTIPLE;
    ids: string[];
};
/**
 * SingleMapping
 * @alpha
 */
export declare namespace SingleMapping {
    const schema: JSONSchema<SingleMapping>;
    const validate: ValidateFunction<Mapping>;
}
/**
 * AnyMapping
 * @alpha
 */
export declare namespace AnyMapping {
    const schema: JSONSchema<AnyMapping>;
    const validate: ValidateFunction<Mapping>;
}
/**
 * RangeMapping
 * @alpha
 */
export declare namespace RangeMapping {
    const _fromLessThanOrEqualTo: KeywordDefinition;
    const schema: JSONSchema<RangeMapping>;
    const validate: ValidateFunction<Mapping>;
}
/**
 * MultipleMapping
 * @alpha
 */
export declare namespace MultipleMapping {
    const schema: JSONSchema<MultipleMapping>;
    const validate: ValidateFunction<Mapping>;
}
/**
 * Mapping
 * @alpha
 */
export declare namespace Mapping {
    const schema: JSONSchema<Mapping>;
    const validate: ValidateFunction<Mapping>;
}
/**
 * Mappings
 * @alpha
 */
export declare namespace Mappings {
    const _isMappingsValid: FuncKeywordDefinition;
    const innerSchema: JSONSchema<Record<ContractAddress, Mapping[]>>;
    const schema: JSONSchema<Mappings>;
    const validate: ValidateFunction<Mappings>;
}
export type MappingsHelper = {
    getMappings(): Mappings;
    addMapping(network: ContractNetwork, contractAddress: ContractAddress, mapping: Mapping): void;
    includesNft(network: ContractNetwork, contractAddress: ContractAddress, tokenId: string): boolean;
};
export declare class AddMappingError extends Error {
    existingMapping: Mapping;
    conflictingMapping: Mapping;
    constructor(message: string, existingMapping: Mapping, conflictingMapping: Mapping);
}
export declare function createMappingsHelper(initial?: Mappings): MappingsHelper;
//# sourceMappingURL=linked-wearable-mappings.d.ts.map