type SettingsValue = {
    key: string;
    value: string;
    domain?: string;
};
type DeleteSettingsValue = {
    key: string;
    domain: string;
};
interface SettingsManager {
    get: (key: string, domain?: string) => Promise<string | undefined>;
    set: (settings: SettingsValue[] | SettingsValue) => Promise<void>;
    delete: (args: DeleteSettingsValue | DeleteSettingsValue[] | string | string[]) => Promise<void>;
}

type MetadataEntry = {
    key: string;
    value: string;
};
/**
 * TODO Rename "Callback" suffixes, these are not callbacks
 */
type FetchMetadataCallback = () => Promise<MetadataEntry[]>;
type MutateMetadataCallback = (metadata: MetadataEntry[]) => Promise<MetadataEntry[]>;
type DeleteMetadataCallback = (keys: string[]) => Promise<void>;
interface MetadataManagerConfig {
    fetchMetadata: FetchMetadataCallback;
    mutateMetadata: MutateMetadataCallback;
    deleteMetadata: DeleteMetadataCallback;
}
/**
 * Metadata Manager use app metadata to store settings.
 * To minimize network calls, once fetched metadata are cached.
 * Cache invalidation occurs if any value is set.
 *
 *
 */
declare class MetadataManager implements SettingsManager {
    private settings;
    private fetchMetadata;
    private mutateMetadata;
    private deleteMetadata;
    constructor({ fetchMetadata, mutateMetadata, deleteMetadata }: MetadataManagerConfig);
    get(key: string, domain?: string): Promise<string | undefined>;
    set(settings: SettingsValue[] | SettingsValue): Promise<void>;
    /**
     * Typescript doesn't properly infer arguments, so they have to be rewritten explicitly
     */
    delete(args: DeleteSettingsValue | DeleteSettingsValue[] | string | string[]): Promise<void>;
}

type EncryptCallback = (value: string, secret: string) => string;
type DecryptCallback = (value: string, secret: string) => string;
/**
 * Encrypt string using AES-256
 */
declare const encrypt: (data: string, key: string) => string;
/**
 * Decrypt string encrypted with AES-256
 */
declare const decrypt: (data: string, key: string) => string;
interface EncryptedMetadataManagerConfig extends MetadataManagerConfig {
    encryptionKey: string;
    encryptionMethod?: EncryptCallback;
    decryptionMethod?: DecryptCallback;
}
/**
 * Encrypted Metadata Manager use app metadata to store settings.
 * To minimize network calls, once fetched metadata are cached.
 * Cache invalidation occurs if any value is set.
 *
 * By default data encryption use AES-256 algorithm. If you want to use a different
 * method, provide `encryptionMethod` and `decryptionMethod`.
 */
declare class EncryptedMetadataManager implements SettingsManager {
    private encryptionKey;
    private encryptionMethod;
    private decryptionMethod;
    private metadataManager;
    constructor({ fetchMetadata, mutateMetadata, encryptionKey, encryptionMethod, decryptionMethod, deleteMetadata, }: EncryptedMetadataManagerConfig);
    get(key: string, domain?: string): Promise<string | undefined>;
    set(settings: SettingsValue[] | SettingsValue): Promise<void>;
    delete(args: DeleteSettingsValue | DeleteSettingsValue[] | string | string[]): Promise<void>;
}

export { type DecryptCallback, type DeleteMetadataCallback, type DeleteSettingsValue, type EncryptCallback, EncryptedMetadataManager, type FetchMetadataCallback, type MetadataEntry, MetadataManager, type MetadataManagerConfig, type MutateMetadataCallback, type SettingsManager, type SettingsValue, decrypt, encrypt };