/// <reference types="node" />
import { DiffieHellman, EncryptedMessageT, HDPathRadixT, PrivateKeyT, PublicKeyT, SignatureT } from "../../crypto/index";
import { BuiltTransactionReadyToSign } from "../../primitives/index";
import { ResultAsync } from "neverthrow";
import { Observable } from "rxjs";
import { Option } from "prelude-ts";
export declare type PrivateKeyToSigningKeyInput = Readonly<{
    privateKey: PrivateKeyT;
    name?: string;
}>;
export declare type AddSigningKeyByPrivateKeyInput = PrivateKeyToSigningKeyInput & {
    alsoSwitchTo?: boolean;
};
export declare type Signing = {
    signHash: (hashedMessage: Buffer) => Observable<SignatureT>;
    sign: (tx: BuiltTransactionReadyToSign, nonXrdHRP?: string) => ResultAsync<SignatureT, Error>;
};
export declare type SigningKeyEncryptionInput = {
    plaintext: Buffer | string;
    publicKeyOfOtherParty: PublicKeyT;
};
export declare type Encrypting = {
    encrypt: (input: SigningKeyEncryptionInput) => Observable<EncryptedMessageT>;
};
export declare type SigningKeyDecryptionInput = {
    encryptedMessage: Buffer | EncryptedMessageT;
    publicKeyOfOtherParty: PublicKeyT;
};
export declare type Decrypting = {
    decrypt: (input: SigningKeyDecryptionInput) => Observable<string>;
};
export declare enum HDSigningKeyTypeIdentifier {
    LOCAL = "LOCAL",
    HARDWARE_OR_REMOTE = "HARDWARE_OR_REMOTE"
}
export declare enum SigningKeyTypeIdentifier {
    HD_SIGNING_KEY = "HD_SIGNING_KEY",
    NON_HD_SIGNING_KEY = "NON_HD_SIGNING_KEY"
}
export declare type BaseSigningKeyTypeT<T extends SigningKeyTypeIdentifier> = {
    typeIdentifier: T;
    isHDSigningKey: boolean;
    isHardwareSigningKey: boolean;
    uniqueKey: string;
};
export declare type SigningKeyTypeHDT = BaseSigningKeyTypeT<SigningKeyTypeIdentifier.HD_SIGNING_KEY> & {
    hdSigningKeyType: HDSigningKeyTypeIdentifier;
    hdPath: HDPathRadixT;
};
export declare type SigningKeyTypeNonHDT = BaseSigningKeyTypeT<SigningKeyTypeIdentifier.NON_HD_SIGNING_KEY> & {
    name?: string;
};
export declare type SigningKeyTypeT = SigningKeyTypeHDT | SigningKeyTypeNonHDT;
export declare type SigningKeyT = Signing & Encrypting & Decrypting & {
    __diffieHellman: DiffieHellman;
    type: SigningKeyTypeT;
    publicKey: PublicKeyT;
    getPublicKeyDisplayOnlyAddress: () => Observable<PublicKeyT>;
    uniqueIdentifier: string;
    toString: () => string;
    equals: (other: SigningKeyT) => boolean;
    hdPath?: HDPathRadixT;
    isHDSigningKey: boolean;
    isHardwareSigningKey: boolean;
    isLocalHDSigningKey: boolean;
};
export declare type SigningKeysT = Readonly<{
    toString: () => string;
    equals: (other: SigningKeysT) => boolean;
    getHDSigningKeyByHDPath: (hdPath: HDPathRadixT) => Option<SigningKeyT>;
    getAnySigningKeyByPublicKey: (publicKey: PublicKeyT) => Option<SigningKeyT>;
    all: SigningKeyT[];
    hdSigningKeys: () => SigningKeyT[];
    localHDSigningKeys: () => SigningKeyT[];
    hardwareHDSigningKeys: () => SigningKeyT[];
    nonHDSigningKeys: () => SigningKeyT[];
    size: () => number;
}>;
//# sourceMappingURL=_types.d.ts.map