import { IKeyManager, IPluginMethodMap, TKeyType, KeyMetadata, ManagedKeyInfo, MinimalImportableKey, IKeyManagerSignArgs, IKey } from '@veramo/core';
import { KeyManager, AbstractKeyStore, AbstractKeyManagementSystem } from '@veramo/key-manager';
export * from '@veramo/key-manager';

type PartialKey = ManagedKeyInfo & {
    privateKeyHex: string;
};
interface ISphereonKeyManager extends IKeyManager, IPluginMethodMap {
    keyManagerCreate(args: ISphereonKeyManagerCreateArgs): Promise<PartialKey>;
    keyManagerImport(key: MinimalImportableKey): Promise<PartialKey>;
    keyManagerSign(args: ISphereonKeyManagerSignArgs): Promise<string>;
    /**
     * Verifies a signature using the key
     *
     * Does not exist in IKeyManager
     * @param args
     */
    keyManagerVerify(args: ISphereonKeyManagerVerifyArgs): Promise<boolean>;
    keyManagerListKeys(): Promise<Array<ManagedKeyInfo>>;
    /**
     * Get the KMS registered as default. Handy when no explicit KMS is provided for a function
     */
    keyManagerGetDefaultKeyManagementSystem(): Promise<string>;
    /**
     * Set keys to expired and remove keys eligible for deletion.
     * @param args
     */
    keyManagerHandleExpirations(args: ISphereonKeyManagerHandleExpirationsArgs): Promise<Array<ManagedKeyInfo>>;
}
interface IkeyOptions {
    /**
     * Is this a temporary key?
     */
    ephemeral?: boolean;
    /**
     * Expiration and remove the key
     */
    expiration?: {
        expiryDate?: Date;
        removalDate?: Date;
    };
}
/**
 * Input arguments for {@link ISphereonKeyManager.keyManagerCreate | keyManagerCreate}
 * @public
 */
interface ISphereonKeyManagerCreateArgs {
    /**
     * Key type
     */
    type: TKeyType;
    /**
     * Key Management System
     */
    kms?: string;
    /**
     * Key options
     */
    opts?: IkeyOptions;
    /**
     * Optional. Key meta data
     */
    meta?: KeyMetadata;
}
declare function hasKeyOptions(object: any): object is {
    opts?: IkeyOptions;
};
/**
 * Input arguments for {@link ISphereonKeyManager.keyManagerGet | keyManagerGet}
 * @public
 */
interface IKeyManagerGetArgs {
    /**
     * Key ID
     */
    kid: string;
}
/**
 * Input arguments for {@link ISphereonKeyManager.keyManagerDelete | keyManagerDelete}
 * @public
 */
interface IKeyManagerDeleteArgs {
    /**
     * Key ID
     */
    kid: string;
}
/**
 * Input arguments for {@link ISphereonKeyManagerSignArgs.keyManagerSign | keyManagerSign}
 * @public
 */
interface ISphereonKeyManagerSignArgs extends IKeyManagerSignArgs {
    /**
     * Data to sign
     */
    data: string | Uint8Array;
}
interface ISphereonKeyManagerHandleExpirationsArgs {
    skipRemovals?: boolean;
}
interface ISphereonKeyManagerVerifyArgs {
    kms?: string;
    publicKeyHex: string;
    type: TKeyType;
    algorithm?: string;
    data: Uint8Array;
    signature: string;
}
declare const isDefined: <T extends unknown>(object: T | undefined) => object is T;

declare const sphereonKeyManagerMethods: Array<string>;
declare class SphereonKeyManager extends KeyManager {
    private kmsStore;
    private readonly availableKmses;
    _defaultKms: string;
    readonly kmsMethods: ISphereonKeyManager;
    constructor(options: {
        store: AbstractKeyStore;
        kms: Record<string, AbstractKeyManagementSystem>;
        defaultKms?: string;
    });
    private syncPreProvisionedKeys;
    private syncPreProvisionedKeysForKms;
    keyManagerGetDefaultKeyManagementSystem(): Promise<string>;
    keyManagerCreate(args: ISphereonKeyManagerCreateArgs): Promise<ManagedKeyInfo>;
    keyManagerSign(args: ISphereonKeyManagerSignArgs): Promise<string>;
    keyManagerVerify(args: ISphereonKeyManagerVerifyArgs): Promise<boolean>;
    keyManagerListKeys(): Promise<ManagedKeyInfo[]>;
    keyManagerHandleExpirations(args: ISphereonKeyManagerHandleExpirationsArgs): Promise<Array<ManagedKeyInfo>>;
    private getKmsByName;
    keyManagerGet({ kid }: IKeyManagerGetArgs): Promise<IKey>;
    get defaultKms(): string;
    set defaultKms(kms: string);
    setKms(name: string, kms: AbstractKeyManagementSystem): void;
}

declare const schema: any;

export { type IKeyManagerDeleteArgs, type IKeyManagerGetArgs, type ISphereonKeyManager, type ISphereonKeyManagerCreateArgs, type ISphereonKeyManagerHandleExpirationsArgs, type ISphereonKeyManagerSignArgs, type ISphereonKeyManagerVerifyArgs, type IkeyOptions, type PartialKey, SphereonKeyManager, hasKeyOptions, isDefined, schema, sphereonKeyManagerMethods };