import { type Algorithm, type DeriveOptions, type KeyData, type KeyId, type KeyStoreState, type KeyType, type SeedData, type XHDDomainP256KeyData } from "@algorandfoundation/keystore";
import type { Store } from "@tanstack/store";
import type { BufferLike, CryptoKey, EncryptDecryptParams, SubtleAlgorithm } from "react-native-quick-crypto";
/**
 * Removes a key from the reactive store and persistent storage.
 * @param params - The removal parameters
 * @param params.store - The reactive store instance
 * @param params.keyId - The ID of the key to remove
 */
export declare function removeKey({ store, keyId, }: {
    store: Store<KeyStoreState>;
    keyId: string;
}): Promise<void>;
/**
 * Clears all keys from the reactive store and persistent storage.
 * @param params - The clear parameters
 * @param params.store - The reactive store instance
 */
export declare function clear({ store, }: {
    store: Store<KeyStoreState>;
}): Promise<void>;
/**
 * Generates a new key pair, stores it, and updates the reactive store.
 * Supports various algorithm types via options.
 * @param options - The generation parameters
 * @param options.store - The reactive store instance
 * @param options.algorithm - The algorithm to use for generation
 * @param options.extractable - Whether the private key can be exported
 * @param options.keyUsages - Intended usages for the key
 * @returns The generated KeyId
 */
export declare function generateKey(options: {
    store: Store<KeyStoreState>;
    type: KeyType;
    algorithm: Algorithm;
    extractable: boolean;
    keyUsages: KeyUsage[];
    params?: Record<string, any>;
}): Promise<KeyId>;
export declare function importSeed({ store, seed, name, id, }: {
    store: Store<KeyStoreState>;
    seed: Uint8Array | string;
    name?: string;
    id?: KeyId;
}): Promise<KeyId>;
export declare function parsePath(path: string): number[];
/**
 * Derives a new key from an existing seed in the keystore.
 * @param params - The derivation parameters
 * @param params.store - The reactive store instance
 * @param params.seedId - The ID of the seed to derive from
 * @param params.path - The derivation path
 * @param params.options - Optional derivation settings
 * @returns The ID of the derived key
 * @todo: Move to keystore
 */
export declare function deriveFromSeed({ store, seedId, path, options, }: {
    store: Store<KeyStoreState>;
    seedId: KeyId;
    path: string;
    options?: DeriveOptions;
}): Promise<KeyId>;
export declare function importEd25519Key({ store, keyData, seed, }: {
    store: Store<KeyStoreState>;
    keyData: KeyData;
    seed?: SeedData;
}): Promise<KeyId>;
export declare function importXHDDomainP256Key({ store, keyData, }: {
    store: Store<KeyStoreState>;
    keyData: Omit<XHDDomainP256KeyData, "id">;
}): Promise<KeyId>;
export declare function importKey({ store, keyData, }: {
    store: Store<KeyStoreState>;
    keyData: Omit<KeyData, "id"> | Uint8Array | string;
}): Promise<KeyId>;
export declare function exportKey({ store, id, }: {
    store: Store<KeyStoreState>;
    id: string;
    options?: any;
}): Promise<KeyData>;
export declare function decryptWithKey({ store, id, data, }: {
    store: Store<KeyStoreState>;
    id: KeyId;
    data: Uint8Array;
    algorithm?: string;
}): Promise<Uint8Array>;
export declare function wrapKey(_options: {
    store: Store<KeyStoreState>;
    format: any;
    key: CryptoKey;
    wrappingKey: CryptoKey;
    wrapAlgorithm: EncryptDecryptParams;
}): Promise<ArrayBuffer>;
export declare function unwrapKey(_options: {
    store: Store<KeyStoreState>;
    format: any;
    wrappedKey: BufferLike;
    unwrappingKey: CryptoKey;
    unwrapAlgorithm: EncryptDecryptParams;
    unwrappedKeyAlgorithm: SubtleAlgorithm;
    extractable: boolean;
    keyUsages: KeyUsage[];
}): Promise<CryptoKey>;
//# sourceMappingURL=store.d.ts.map