///
import { Observable } from "rxjs";
import { ECPointOnCurveT, HDPathRadixT, PublicKeyT, SignatureT } from "../crypto/index";
import { BuiltTransactionReadyToSign } from "../primitives/index";
import { ResultAsync } from "neverthrow";
export declare type SemVerT = Readonly<{
major: number;
minor: number;
patch: number;
equals: (other: SemVerT) => boolean;
toString: () => string;
}>;
export declare type AtPath = Readonly<{
path?: HDPathRadixT;
}>;
export declare type GetPublicKeyInput = AtPath & Readonly<{
display?: boolean;
verifyAddressOnly?: boolean;
}>;
export declare type SignTXOutput = Readonly<{
signature: SignatureT;
signatureV: number;
hashCalculatedByLedger: Buffer;
}>;
export declare type SignHashInput = GetPublicKeyInput & Readonly<{
hashToSign: Buffer;
}>;
export declare type KeyExchangeInput = AtPath & Readonly<{
publicKeyOfOtherParty: PublicKeyT;
display?: "encrypt" | "decrypt";
}>;
export declare type HardwareSigningKeyT = Readonly<{
keyExchange: (publicKeyOfOtherParty: PublicKeyT, display?: "encrypt" | "decrypt") => Observable;
publicKey: PublicKeyT;
getPublicKeyDisplayOnlyAddress: () => Observable;
signHash: (hashedMessage: Buffer) => Observable;
sign: (tx: BuiltTransactionReadyToSign, nonXrdHRP?: string) => ResultAsync;
}>;
export declare type SignTransactionInput = Readonly<{
tx: BuiltTransactionReadyToSign;
path: HDPathRadixT;
nonXrdHRP?: string;
}>;
export declare type HardwareWalletT = Readonly<{
getVersion: () => Observable;
getPublicKey: (input: GetPublicKeyInput) => Observable;
signHash: (input: SignHashInput) => Observable;
signTransaction: (input: SignTransactionInput) => ResultAsync;
keyExchange: (input: KeyExchangeInput) => Observable;
makeSigningKey: (path: HDPathRadixT, verificationPrompt?: boolean) => Observable;
}>;
//# sourceMappingURL=_types.d.ts.map