@ohos-ports/react-native-quick-crypto 0.0.0-stage → 1.1.8-beta.0

package/lib/typescript/hkdf.d.ts

@@ -0,0 +1,26 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { BinaryLike } from './utils';
+import type { CryptoKey } from './keys';
+type KeyMaterial = BinaryLike;
+type Salt = BinaryLike;
+type Info = BinaryLike;
+export interface HkdfAlgorithm {
+    name: string;
+    hash: string | {
+        name: string;
+    };
+    salt: BinaryLike;
+    info: BinaryLike;
+}
+export interface HkdfCallback {
+    (err: Error | null, derivedKey?: Buffer): void;
+}
+export declare function hkdf(digest: string, key: KeyMaterial, salt: Salt, info: Info, keylen: number, callback: HkdfCallback): void;
+export declare function hkdfSync(digest: string, key: KeyMaterial, salt: Salt, info: Info, keylen: number): Buffer;
+export declare function hkdfExtractSync(digest: string, ikm: KeyMaterial, salt?: Salt): Buffer;
+export declare function hkdfExtract(digest: string, ikm: KeyMaterial, salt: Salt, callback: HkdfCallback): void;
+export declare function hkdfExpandSync(digest: string, prk: KeyMaterial, info: Info, keylen: number): Buffer;
+export declare function hkdfExpand(digest: string, prk: KeyMaterial, info: Info, keylen: number, callback: HkdfCallback): void;
+export declare function hkdfDeriveBits(algorithm: HkdfAlgorithm, baseKey: CryptoKey, length: number): ArrayBuffer;
+export {};
+//# sourceMappingURL=hkdf.d.ts.map

package/lib/typescript/hkdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hkdf.d.ts","sourceRoot":"","sources":["../../src/hkdf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAIxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAExC,KAAK,WAAW,GAAG,UAAU,CAAC;AAC9B,KAAK,IAAI,GAAG,UAAU,CAAC;AACvB,KAAK,IAAI,GAAG,UAAU,CAAC;AAEvB,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAChC,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChD;AA2ED,wBAAgB,IAAI,CAClB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,YAAY,GACrB,IAAI,CAgCN;AAED,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,GACb,MAAM,CAmBR;AAID,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,WAAW,EAChB,IAAI,GAAE,IAAwB,GAC7B,MAAM,CAgBR;AAID,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,YAAY,GACrB,IAAI,CAyBN;AAID,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,GACb,MAAM,CAuBR;AAGD,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,YAAY,GACrB,IAAI,CAgCN;AAED,wBAAgB,cAAc,CAC5B,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,SAAS,EAClB,MAAM,EAAE,MAAM,GACb,WAAW,CA4Bb"}

package/lib/typescript/hmac.d.ts

@@ -0,0 +1,66 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { Stream } from 'readable-stream';
+import type { TransformOptions } from 'readable-stream';
+import type { BinaryLike, Encoding } from './utils/types';
+declare class Hmac extends Stream.Transform {
+    private algorithm;
+    private key;
+    private native;
+    private validate;
+    /**
+     * @internal use `createHmac()` instead
+     */
+    private constructor();
+    /**
+     * Updates the `Hmac` content with the given `data`, the encoding of which is given in `inputEncoding`.
+     * If `encoding` is not provided, and the `data` is a string, an encoding of `'utf8'` is enforced.
+     * If `data` is a `Buffer`, `TypedArray`, or`DataView`, then `inputEncoding` is ignored.
+     *
+     * This can be called many times with new data as it is streamed.
+     * @since v1.0.0
+     * @param inputEncoding The `encoding` of the `data` string.
+     */
+    update(data: BinaryLike): Hmac;
+    update(data: BinaryLike, inputEncoding: Encoding): Hmac;
+    /**
+     * Calculates the HMAC digest of all of the data passed using `hmac.update()`.
+     * If `encoding` is provided a string is returned; otherwise a `Buffer` is returned;
+     *
+     * The `Hmac` object can not be used again after `hmac.digest()` has been
+     * called. Multiple calls to `hmac.digest()` will result in an error being thrown.
+     * @since v1.0.0
+     * @param encoding The `encoding` of the return value.
+     */
+    digest(): Buffer;
+    digest(encoding: Encoding): string;
+    _transform(chunk: BinaryLike, encoding: BufferEncoding, callback: (err?: Error | null) => void): void;
+    _flush(callback: (err?: Error | null) => void): void;
+}
+/**
+ * Creates and returns an `Hmac` object that uses the given `algorithm` and `key`.
+ * Optional `options` argument controls stream behavior.
+ *
+ * The `algorithm` is dependent on the available algorithms supported by the
+ * version of OpenSSL on the platform. Examples are `'sha256'`, `'sha512'`, etc.
+ * On recent releases of OpenSSL, `openssl list -digest-algorithms` will
+ * display the available digest algorithms.
+ *
+ * Example: generating the sha256 HMAC of a file
+ *
+ * ```js
+ * import crypto from 'react-native-quick-crypto';
+ *
+ * const hmac = crypto.createHmac('sha256', 'secret-key');
+ * hmac.update('message to hash');
+ * const digest = hmac.digest('hex');
+ * console.log(digest); // prints HMAC digest in hexadecimal format
+ * ```
+ * @since v1.0.0
+ * @param options `stream.transform` options
+ */
+export declare function createHmac(algorithm: string, key: BinaryLike, options?: TransformOptions): Hmac;
+export declare const hmacExports: {
+    createHmac: typeof createHmac;
+};
+export {};
+//# sourceMappingURL=hmac.d.ts.map

package/lib/typescript/hmac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.d.ts","sourceRoot":"","sources":["../../src/hmac.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAS1D,cAAM,IAAK,SAAQ,MAAM,CAAC,SAAS;IACjC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,MAAM,CAAa;IAE3B,OAAO,CAAC,QAAQ;IAOhB;;OAEG;IACH,OAAO;IAYP;;;;;;;;OAQG;IACH,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAC9B,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,aAAa,EAAE,QAAQ,GAAG,IAAI;IAevD;;;;;;;;OAQG;IACH,MAAM,IAAI,MAAM;IAChB,MAAM,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM;IAclC,UAAU,CACR,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI;IASxC,MAAM,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI;CAQ9C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,UAAU,EACf,OAAO,CAAC,EAAE,gBAAgB,GACzB,IAAI,CAON;AAED,eAAO,MAAM,WAAW;;CAEvB,CAAC"}

package/lib/typescript/index.d.ts

@@ -0,0 +1,240 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+declare global {
+    var base64ToArrayBuffer: (s: string, removeLinebreaks?: boolean) => ArrayBuffer;
+    var base64FromArrayBuffer: (b: ArrayBuffer, urlSafe?: boolean) => string;
+}
+import * as argon2Module from './argon2';
+import * as keys from './keys';
+import * as blake3 from './blake3';
+import * as cipher from './cipher';
+import * as ed from './ed';
+import * as hkdf from './hkdf';
+import * as prime from './prime';
+import * as scrypt from './scrypt';
+import * as random from './random';
+import * as ecdh from './ecdh';
+import * as dh from './diffie-hellman';
+import * as mlkem from './mlkem';
+import { Certificate } from './certificate';
+import { X509Certificate } from './x509certificate';
+import { getCurves } from './ec';
+import * as utils from './utils';
+import * as subtle from './subtle';
+/**
+ * Loosely matches Node.js {crypto} with some unimplemented functionality.
+ * See `docs/implementation-coverage.md` for status.
+ */
+declare const QuickCrypto: {
+    Certificate: typeof Certificate;
+    X509Certificate: typeof X509Certificate;
+    getCurves: typeof getCurves;
+    constants: {
+        readonly RSA_PKCS1_PADDING: 1;
+        readonly RSA_NO_PADDING: 3;
+        readonly RSA_PKCS1_OAEP_PADDING: 4;
+        readonly RSA_X931_PADDING: 5;
+        readonly RSA_PKCS1_PSS_PADDING: 6;
+        readonly RSA_PSS_SALTLEN_DIGEST: -1;
+        readonly RSA_PSS_SALTLEN_MAX_SIGN: -2;
+        readonly RSA_PSS_SALTLEN_AUTO: -2;
+        readonly POINT_CONVERSION_COMPRESSED: 2;
+        readonly POINT_CONVERSION_UNCOMPRESSED: 4;
+        readonly POINT_CONVERSION_HYBRID: 6;
+        readonly DH_CHECK_P_NOT_PRIME: 1;
+        readonly DH_CHECK_P_NOT_SAFE_PRIME: 2;
+        readonly DH_UNABLE_TO_CHECK_GENERATOR: 4;
+        readonly DH_NOT_SUITABLE_GENERATOR: 8;
+        readonly OPENSSL_VERSION_NUMBER: 805306368;
+    };
+    Buffer: typeof Buffer;
+    isCryptoKeyPair(result: keys.CryptoKey | utils.CryptoKeyPair): result is utils.CryptoKeyPair;
+    PQC_SEEDLESS_PKCS8_LENGTHS: Readonly<Record<string, number>>;
+    Subtle: typeof subtle.Subtle;
+    subtle: subtle.Subtle;
+    rejectSharedArrayBuffer(buf: unknown): void;
+    toArrayBuffer(buf: Buffer | import("safe-buffer").Buffer | ArrayBufferView): ArrayBuffer;
+    bufferLikeToArrayBuffer(buf: utils.BufferLike): ArrayBuffer;
+    binaryLikeToArrayBuffer(input: utils.BinaryLikeNode, encoding?: string): ArrayBuffer;
+    ab2str(buf: ArrayBuffer, encoding?: string, start?: number, end?: number): string;
+    bufferToString(buf: ArrayBuffer, encoding?: string, start?: number, end?: number): string;
+    stringToBuffer(str: string, encoding?: string): ArrayBuffer;
+    abvToArrayBuffer: (buf: utils.ABV) => ArrayBuffer;
+    kEmptyObject: any;
+    ensureBytes(title: string, hex: utils.Hex, expectedLength?: number): Uint8Array;
+    isBytes(a: unknown): a is Uint8Array;
+    hexToBytes(hex: string): Uint8Array;
+    lazyDOMException(message: string, domName: string | {
+        name: string;
+        cause: unknown;
+    }): Error;
+    QuotaExceededError: typeof utils.QuotaExceededError;
+    normalizeHashName(algo: string | utils.HashAlgorithm | {
+        name: string;
+    } | undefined, context?: utils.HashContext): string;
+    HashContext: typeof utils.HashContext;
+    timingSafeEqual(a: utils.ABV, b: utils.ABV): boolean;
+    KFormatType: typeof utils.KFormatType;
+    KeyType: typeof utils.KeyType;
+    KeyEncoding: typeof utils.KeyEncoding;
+    KeyFormat: typeof utils.KeyFormat;
+    kNamedCurveAliases: {
+        readonly 'P-256': "prime256v1";
+        readonly 'P-384': "secp384r1";
+        readonly 'P-521': "secp521r1";
+    };
+    KeyVariant: typeof utils.KeyVariant;
+    validateFunction(f: unknown): boolean;
+    isStringOrBuffer(val: unknown): val is string | ArrayBuffer;
+    validateObject<T>(value: unknown, name: string, options?: {
+        allowArray: boolean;
+        allowFunction: boolean;
+        nullable: boolean;
+    } | null): value is T;
+    getSortedUsages(usages: utils.KeyUsage[]): utils.KeyUsage[];
+    validateJwkStructure(jwk: utils.JWK, extractable: boolean, keyUsages: utils.KeyUsage[], expectedUse: "sig" | "enc"): void;
+    hasAnyNotIn(set: string[], checks: string[]): boolean;
+    validateMaxBufferLength: (data: utils.BinaryLike | utils.BufferLike, name: string) => void;
+    getUsagesUnion: (usageSet: utils.KeyUsage[], // @ts-expect-error subtle isn't fully implemented and Cryptokey is missing
+    ...usages: utils.KeyUsage[]) => utils.KeyUsage[];
+    validateKeyOps: (keyOps: utils.KeyUsage[] | undefined, usagesSet: utils.KeyUsage[]) => void;
+    setDefaultEncoding(encoding: utils.Encoding): void;
+    getDefaultEncoding(): utils.Encoding;
+    normalizeEncoding(enc: string): "ascii" | "utf8" | "utf16le" | "base64" | "latin1" | "hex" | undefined;
+    validateEncoding(data: string, encoding: string): void;
+    getUIntOption(options: Readonly<Record<string, unknown>> | undefined, key: string): number | undefined;
+    encapsulate(key: keys.KeyObject | keys.CryptoKey | utils.BinaryLike | mlkem.KeyInputObject, callback?: (err: Error | null, result?: utils.EncapsulateResult) => void): utils.EncapsulateResult | void;
+    decapsulate(key: keys.KeyObject | keys.CryptoKey | utils.BinaryLike | mlkem.KeyInputObject, ciphertext: utils.BinaryLike, callback?: (err: Error | null, result?: ArrayBuffer) => void): ArrayBuffer | void;
+    mlkem_generateKeyPairWebCrypto(variant: mlkem.MlKemVariant, extractable: boolean, keyUsages: utils.KeyUsage[]): Promise<utils.CryptoKeyPair>;
+    MlKem: typeof mlkem.MlKem;
+    createDiffieHellman(primeOrSize: number | string | Buffer, primeEncodingOrGenerator?: string | number | Buffer, generator?: number | string | Buffer, _generatorEncoding?: string): dh.DiffieHellman;
+    getDiffieHellman(groupName: string): dh.DiffieHellman;
+    DiffieHellman: typeof dh.DiffieHellman;
+    createDiffieHellmanGroup: typeof dh.getDiffieHellman;
+    createECDH(curveName: string): ecdh.ECDH;
+    ECDH: typeof ecdh.ECDH;
+    randomFill<T extends utils.ABV>(buffer: T, callback: utils.RandomCallback<T>): void;
+    randomFill<T extends utils.ABV>(buffer: T, offset: number, callback: utils.RandomCallback<T>): void;
+    randomFill<T extends utils.ABV>(buffer: T, offset: number, size: number, callback: utils.RandomCallback<T>): void;
+    randomFillSync<T extends utils.ABV>(buffer: T, offset?: number, size?: number): T;
+    randomBytes(size: number): Buffer;
+    randomBytes(size: number, callback: (err: Error | null, buf?: Buffer) => void): void;
+    randomInt(max: number, callback: (err: Error | null, value: number) => void): void;
+    randomInt(max: number): number;
+    randomInt(min: number, max: number, callback: (err: Error | null, value: number) => void): void;
+    randomInt(min: number, max: number): number;
+    getRandomValues(data: random.RandomTypedArrays): random.RandomTypedArrays;
+    randomUUID(options?: random.RandomUUIDOptions): string;
+    randomUUIDv7(options?: random.RandomUUIDOptions): string;
+    rng: typeof random.randomBytes;
+    pseudoRandomBytes: typeof random.randomBytes;
+    prng: typeof random.randomBytes;
+    scrypt(password: utils.BinaryLike, salt: utils.BinaryLike, keylen: number, options?: scrypt.ScryptOptions | ((err: Error | null, derivedKey?: Buffer) => void), callback?: (err: Error | null, derivedKey?: Buffer) => void): void;
+    scryptSync(password: utils.BinaryLike, salt: utils.BinaryLike, keylen: number, options?: scrypt.ScryptOptions): Buffer;
+    generatePrimeSync(size: number, options?: prime.GeneratePrimeOptions): Buffer | bigint;
+    generatePrime(size: number, options: prime.GeneratePrimeOptions | ((err: Error | null, prime: Buffer | bigint) => void), callback?: (err: Error | null, prime: Buffer | bigint) => void): void;
+    checkPrimeSync(candidate: utils.BinaryLike | bigint, options?: prime.CheckPrimeOptions): boolean;
+    checkPrime(candidate: utils.BinaryLike | bigint, options: prime.CheckPrimeOptions | ((err: Error | null, result: boolean) => void), callback?: (err: Error | null, result: boolean) => void): void;
+    pbkdf2(password: utils.BinaryLike, salt: utils.BinaryLike, iterations: number, keylen: number, digest: string, callback: (err: Error | null, derivedKey?: Buffer) => void): void;
+    pbkdf2Sync(password: utils.BinaryLike, salt: utils.BinaryLike, iterations: number, keylen: number, digest: string): Buffer;
+    pbkdf2DeriveBits(algorithm: utils.SubtleAlgorithm, baseKey: keys.CryptoKey, length: number): Promise<ArrayBuffer>;
+    hkdf(digest: string, key: utils.BinaryLike, salt: utils.BinaryLike, info: utils.BinaryLike, keylen: number, callback: hkdf.HkdfCallback): void;
+    hkdfSync(digest: string, key: utils.BinaryLike, salt: utils.BinaryLike, info: utils.BinaryLike, keylen: number): Buffer;
+    hkdfExtractSync(digest: string, ikm: utils.BinaryLike, salt?: utils.BinaryLike): Buffer;
+    hkdfExtract(digest: string, ikm: utils.BinaryLike, salt: utils.BinaryLike, callback: hkdf.HkdfCallback): void;
+    hkdfExpandSync(digest: string, prk: utils.BinaryLike, info: utils.BinaryLike, keylen: number): Buffer;
+    hkdfExpand(digest: string, prk: utils.BinaryLike, info: utils.BinaryLike, keylen: number, callback: hkdf.HkdfCallback): void;
+    hkdfDeriveBits(algorithm: hkdf.HkdfAlgorithm, baseKey: keys.CryptoKey, length: number): ArrayBuffer;
+    createHmac: typeof import("./hmac").createHmac;
+    createHash: typeof import("./hash").createHash;
+    getHashes: typeof import("./hash").getHashes;
+    hash: typeof import("./hash").hash;
+    asyncDigest: (algorithm: utils.SubtleAlgorithm, data: utils.BufferLike) => Promise<ArrayBuffer>;
+    diffieHellman(options: utils.DiffieHellmanOptions, callback?: utils.DiffieHellmanCallback): Buffer | void;
+    ed_generateKeyPair(isAsync: boolean, type: utils.CFRGKeyPairType, encoding: utils.KeyPairGenConfig, callback: utils.GenerateKeyPairCallback | undefined): utils.GenerateKeyPairReturn | void;
+    ed_generateKeyPairWebCrypto(type: "ed25519" | "ed448", extractable: boolean, keyUsages: utils.KeyUsage[]): Promise<utils.CryptoKeyPair>;
+    x_generateKeyPairWebCrypto(type: "x25519" | "x448", extractable: boolean, keyUsages: utils.KeyUsage[]): Promise<utils.CryptoKeyPair>;
+    xDeriveBits(algorithm: utils.SubtleAlgorithm, baseKey: keys.CryptoKey, length: number | null): ArrayBuffer;
+    Ed: typeof ed.Ed;
+    getCiphers(): string[];
+    getCipherInfo(name: string, options?: {
+        keyLength?: number;
+        ivLength?: number;
+    }): cipher.CipherInfoResult | undefined;
+    createDecipheriv(algorithm: import("crypto").CipherCCMTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options: import("crypto").CipherCCMOptions): cipher.Decipher;
+    createDecipheriv(algorithm: import("crypto").CipherOCBTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options: import("crypto").CipherOCBOptions): cipher.Decipher;
+    createDecipheriv(algorithm: import("crypto").CipherGCMTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options?: import("crypto").CipherGCMOptions): cipher.Decipher;
+    createDecipheriv(algorithm: string, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options?: import("readable-stream").TransformOptions): cipher.Decipher;
+    createCipheriv(algorithm: import("crypto").CipherCCMTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options: import("crypto").CipherCCMOptions): cipher.Cipher;
+    createCipheriv(algorithm: import("crypto").CipherOCBTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options: import("crypto").CipherOCBOptions): cipher.Cipher;
+    createCipheriv(algorithm: import("crypto").CipherGCMTypes, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options?: import("crypto").CipherGCMOptions): cipher.Cipher;
+    createCipheriv(algorithm: string, key: utils.BinaryLikeNode, iv: utils.BinaryLike, options?: import("readable-stream").TransformOptions): cipher.Cipher;
+    xsalsa20(key: Uint8Array, nonce: Uint8Array, data: Uint8Array, output?: Uint8Array | undefined, counter?: number): Uint8Array;
+    createBlake3(opts?: blake3.Blake3Options): blake3.Blake3;
+    blake3: typeof blake3.blake3;
+    Blake3: typeof blake3.Blake3;
+    blake3Exports: {
+        Blake3: typeof blake3.Blake3;
+        createBlake3: typeof blake3.createBlake3;
+        blake3: typeof blake3.blake3;
+    };
+    createSecretKey: typeof keys.createSecretKey;
+    createPublicKey: typeof keys.createPublicKey;
+    createPrivateKey: typeof keys.createPrivateKey;
+    CryptoKey: typeof keys.CryptoKey;
+    generateKey: typeof keys.generateKey;
+    generateKeySync: typeof keys.generateKeySync;
+    generateKeyPair: (type: utils.KeyPairType, options: utils.GenerateKeyPairOptions, callback: utils.GenerateKeyPairCallback) => void;
+    generateKeyPairSync: typeof keys.generateKeyPairSync;
+    AsymmetricKeyObject: typeof keys.AsymmetricKeyObject;
+    KeyObject: typeof keys.KeyObject;
+    createSign: typeof keys.createSign;
+    createVerify: typeof keys.createVerify;
+    sign: typeof keys.sign;
+    verify: typeof keys.verify;
+    Sign: typeof keys.Sign;
+    Verify: typeof keys.Verify;
+    publicEncrypt: typeof keys.publicEncrypt;
+    publicDecrypt: typeof keys.publicDecrypt;
+    privateEncrypt: typeof keys.privateEncrypt;
+    privateDecrypt: typeof keys.privateDecrypt;
+    parsePublicKeyEncoding: typeof keys.parsePublicKeyEncoding;
+    parsePrivateKeyEncoding: typeof keys.parsePrivateKeyEncoding;
+    parseKeyEncoding: typeof keys.parseKeyEncoding;
+    SecretKeyObject: typeof keys.SecretKeyObject;
+    PublicKeyObject: typeof keys.PublicKeyObject;
+    PrivateKeyObject: typeof keys.PrivateKeyObject;
+    isCryptoKey: (obj: any) => boolean;
+    argon2Sync(algorithm: string, params: argon2Module.Argon2Params): Buffer;
+    argon2(algorithm: string, params: argon2Module.Argon2Params, callback: (err: Error | null, result: Buffer) => void): void;
+};
+/**
+ * Optional. Patch global.crypto with react-native-quick-crypto and
+ * global.Buffer with react-native-buffer.
+ */
+export declare const install: () => void;
+export default QuickCrypto;
+export * from './argon2';
+export * from './blake3';
+export { Certificate } from './certificate';
+export { X509Certificate } from './x509certificate';
+export type { CheckOptions, X509LegacyObject } from './x509certificate';
+export * from './cipher';
+export * from './ed';
+export * from './keys';
+export * from './hash';
+export * from './hmac';
+export * from './hkdf';
+export * from './pbkdf2';
+export * from './prime';
+export * from './scrypt';
+export * from './random';
+export * from './ecdh';
+export { getCurves } from './ec';
+export * from './diffie-hellman';
+export * from './mlkem';
+export * from './utils';
+export * from './subtle';
+export { subtle, isCryptoKeyPair } from './subtle';
+export { constants } from './constants';
+export { Buffer } from '@craftzdog/react-native-buffer';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAGxD,OAAO,CAAC,MAAM,CAAC;IAEb,IAAI,mBAAmB,EAAE,CACvB,CAAC,EAAE,MAAM,EACT,gBAAgB,CAAC,EAAE,OAAO,KACvB,WAAW,CAAC;IAEjB,IAAI,qBAAqB,EAAE,CAAC,CAAC,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;CAC1E;AAGD,OAAO,KAAK,YAAY,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,EAAE,MAAM,MAAM,CAAC;AAG3B,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAE/B,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAIjC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAmFqK,cAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BArF3L,yCAA+B,EAAC,YAAe;qBAiC5C,0BACN,EACE,2EAA2E;IAC3E,2BADoB;qBA8BlB,oCACS,EAAC,2BACA;;;;;;qIAkBkhE,CAAC;mKAA85B,CAAC;;;;;;;;;;;;;;+DApB97F,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAlDD,CAAD;gBAEC,CAAF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,OAAO,YAYnB,CAAC;AAYF,eAAe,WAAW,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACxE,cAAc,UAAU,CAAC;AACzB,cAAc,MAAM,CAAC;AACrB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC"}

package/lib/typescript/keys/classes.d.ts

@@ -0,0 +1,95 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { AsymmetricKeyType, EncodingOptions, JWK, KeyDetail, KeyObjectHandle, KeyUsage, SubtleAlgorithm } from '../utils';
+import { KFormatType, KeyEncoding } from '../utils';
+export declare class CryptoKey {
+    keyObject: KeyObject;
+    keyAlgorithm: SubtleAlgorithm;
+    keyUsages: KeyUsage[];
+    keyExtractable: boolean;
+    get [Symbol.toStringTag](): string;
+    constructor(keyObject: KeyObject, keyAlgorithm: SubtleAlgorithm, keyUsages: KeyUsage[], keyExtractable: boolean);
+    inspect(_depth: number, _options: unknown): unknown;
+    get type(): "public" | "secret" | "private";
+    get extractable(): boolean;
+    get algorithm(): SubtleAlgorithm;
+    get usages(): KeyUsage[];
+}
+export declare class KeyObject {
+    handle: KeyObjectHandle;
+    type: 'public' | 'secret' | 'private';
+    get [Symbol.toStringTag](): string;
+    export(options: {
+        format: 'pem';
+    } & EncodingOptions): string | Buffer;
+    export(options?: {
+        format: 'der';
+    } & EncodingOptions): Buffer;
+    export(options?: {
+        format: 'jwk';
+    } & EncodingOptions): JWK;
+    export(options?: EncodingOptions): string | Buffer | JWK;
+    equals(otherKeyObject: KeyObject): boolean;
+    constructor(type: string, handle: KeyObjectHandle);
+    constructor(type: string, key: ArrayBuffer);
+    static from(key: CryptoKey): KeyObject;
+    toCryptoKey(algorithm: SubtleAlgorithm, extractable: boolean, keyUsages: KeyUsage[]): CryptoKey;
+    static createKeyObject(type: string, key: ArrayBuffer, format?: KFormatType, encoding?: KeyEncoding, passphrase?: ArrayBuffer): KeyObject;
+    getAsymmetricKeyType(): undefined;
+    getAsymmetricKeyDetails(): undefined;
+}
+export declare class SecretKeyObject extends KeyObject {
+    constructor(handle: KeyObjectHandle);
+    get symmetricKeySize(): number;
+    export(options: {
+        format: 'pem';
+    } & EncodingOptions): never;
+    export(options: {
+        format: 'der';
+    } & EncodingOptions): Buffer;
+    export(options: {
+        format: 'jwk';
+    } & EncodingOptions): never;
+    export(options?: EncodingOptions): Buffer;
+}
+export declare class AsymmetricKeyObject extends KeyObject {
+    constructor(type: string, handle: KeyObjectHandle);
+    private _asymmetricKeyType?;
+    get asymmetricKeyType(): AsymmetricKeyType;
+    private _asymmetricKeyDetails?;
+    get asymmetricKeyDetails(): KeyDetail;
+    get namedCurve(): string | undefined;
+}
+export declare class PublicKeyObject extends AsymmetricKeyObject {
+    constructor(handle: KeyObjectHandle);
+    export(options: {
+        format: 'pem';
+    } & EncodingOptions): string;
+    export(options: {
+        format: 'der';
+    } & EncodingOptions): Buffer;
+    export(options: {
+        format: 'jwk';
+    } & EncodingOptions): JWK;
+    export(options: {
+        format: 'raw-public';
+    } & EncodingOptions): Buffer;
+}
+export declare class PrivateKeyObject extends AsymmetricKeyObject {
+    constructor(handle: KeyObjectHandle);
+    export(options: {
+        format: 'pem';
+    } & EncodingOptions): string;
+    export(options: {
+        format: 'der';
+    } & EncodingOptions): Buffer;
+    export(options: {
+        format: 'jwk';
+    } & EncodingOptions): JWK;
+    export(options: {
+        format: 'raw-private';
+    } & EncodingOptions): Buffer;
+    export(options: {
+        format: 'raw-seed';
+    } & EncodingOptions): Buffer;
+}
+//# sourceMappingURL=classes.d.ts.map

package/lib/typescript/keys/classes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classes.d.ts","sourceRoot":"","sources":["../../../src/keys/classes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAExD,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,GAAG,EACH,SAAS,EACT,eAAe,EACf,QAAQ,EACR,eAAe,EAChB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAW,WAAW,EAAE,WAAW,EAAmB,MAAM,UAAU,CAAC;AAG9E,qBAAa,SAAS;IACpB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,eAAe,CAAC;IAC9B,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,cAAc,EAAE,OAAO,CAAC;IAExB,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;gBAGC,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,eAAe,EAC7B,SAAS,EAAE,QAAQ,EAAE,EACrB,cAAc,EAAE,OAAO;IASzB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO;IAoBnD,IAAI,IAAI,oCAGP;IAED,IAAI,WAAW,YAEd;IAED,IAAI,SAAS,oBAEZ;IAED,IAAI,MAAM,eAET;CACF;AAED,qBAAa,SAAS;IACpB,MAAM,EAAE,eAAe,CAAC;IACxB,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;IAEtC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,MAAM,GAAG,MAAM;IACrE,MAAM,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,MAAM;IAC7D,MAAM,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,GAAG;IAC1D,MAAM,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,GAAG;IAOxD,MAAM,CAAC,cAAc,EAAE,SAAS,GAAG,OAAO;gBAO9B,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe;gBACrC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW;IA6B1C,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,SAAS,GAAG,SAAS;IAStC,WAAW,CACT,SAAS,EAAE,eAAe,EAC1B,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,QAAQ,EAAE,GACpB,SAAS;IAIZ,MAAM,CAAC,eAAe,CACpB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,WAAW,EAChB,MAAM,CAAC,EAAE,WAAW,EACpB,QAAQ,CAAC,EAAE,WAAW,EACtB,UAAU,CAAC,EAAE,WAAW,GACvB,SAAS;IAgDZ,oBAAoB,IAAI,SAAS;IAIjC,uBAAuB,IAAI,SAAS;CAGrC;AAED,qBAAa,eAAgB,SAAQ,SAAS;gBAChC,MAAM,EAAE,eAAe;IAInC,IAAI,gBAAgB,IAAI,MAAM,CAE7B;IAED,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,KAAK;IAC3D,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,MAAM;IAC5D,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,KAAK;IAC3D,MAAM,CAAC,OAAO,CAAC,EAAE,eAAe,GAAG,MAAM;CAU1C;AAiBD,qBAAa,mBAAoB,SAAQ,SAAS;gBACpC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe;IAIjD,OAAO,CAAC,kBAAkB,CAAC,CAAoB;IAE/C,IAAI,iBAAiB,IAAI,iBAAiB,CAKzC;IAED,OAAO,CAAC,qBAAqB,CAAC,CAAY;IAE1C,IAAI,oBAAoB,cAKvB;IAED,IAAI,UAAU,IAAI,MAAM,GAAG,SAAS,CAEnC;CACF;AAED,qBAAa,eAAgB,SAAQ,mBAAmB;gBAC1C,MAAM,EAAE,eAAe;IAInC,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,MAAM;IAC5D,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,MAAM;IAC5D,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,GAAG;IACzD,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,YAAY,CAAA;KAAE,GAAG,eAAe,GAAG,MAAM;CAoCpE;AAED,qBAAa,gBAAiB,SAAQ,mBAAmB;gBAC3C,MAAM,EAAE,eAAe;IAInC,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,MAAM;IAC5D,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,MAAM;IAC5D,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE,GAAG,eAAe,GAAG,GAAG;IACzD,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,aAAa,CAAA;KAAE,GAAG,eAAe,GAAG,MAAM;IACpE,MAAM,CAAC,OAAO,EAAE;QAAE,MAAM,EAAE,UAAU,CAAA;KAAE,GAAG,eAAe,GAAG,MAAM;CAoClE"}

package/lib/typescript/keys/generateKeyPair.d.ts

@@ -0,0 +1,17 @@
+import { type CryptoKeyPair, type GenerateKeyPairCallback, type GenerateKeyPairOptions, type GenerateKeyPairPromiseReturn, type KeyPairType } from '../utils';
+import { type PublicKeyObject, type PrivateKeyObject } from './classes';
+export declare const generateKeyPair: (type: KeyPairType, options: GenerateKeyPairOptions, callback: GenerateKeyPairCallback) => void;
+export declare const generateKeyPairPromise: (type: KeyPairType, options: GenerateKeyPairOptions) => Promise<GenerateKeyPairPromiseReturn>;
+export type KeyObjectKeyPair = {
+    publicKey: PublicKeyObject;
+    privateKey: PrivateKeyObject;
+};
+type KeyObjectGenerateKeyPairOptions = Omit<GenerateKeyPairOptions, 'publicKeyEncoding' | 'privateKeyEncoding'> & {
+    publicKeyEncoding?: undefined;
+    privateKeyEncoding?: undefined;
+};
+export declare function generateKeyPairSync(type: KeyPairType): KeyObjectKeyPair;
+export declare function generateKeyPairSync(type: KeyPairType, options: KeyObjectGenerateKeyPairOptions): KeyObjectKeyPair;
+export declare function generateKeyPairSync(type: KeyPairType, options: GenerateKeyPairOptions): CryptoKeyPair;
+export {};
+//# sourceMappingURL=generateKeyPair.d.ts.map

package/lib/typescript/keys/generateKeyPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateKeyPair.d.ts","sourceRoot":"","sources":["../../../src/keys/generateKeyPair.ts"],"names":[],"mappings":"AAUA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,4BAA4B,EAIjC,KAAK,WAAW,EAIjB,MAAM,UAAU,CAAC;AAClB,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACtB,MAAM,WAAW,CAAC;AAmHnB,eAAO,MAAM,eAAe,GAC1B,MAAM,WAAW,EACjB,SAAS,sBAAsB,EAC/B,UAAU,uBAAuB,KAChC,IAGF,CAAC;AAIF,eAAO,MAAM,sBAAsB,GACjC,MAAM,WAAW,EACjB,SAAS,sBAAsB,KAC9B,OAAO,CAAC,4BAA4B,CAUtC,CAAC;AAGF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AAEF,KAAK,+BAA+B,GAAG,IAAI,CACzC,sBAAsB,EACtB,mBAAmB,GAAG,oBAAoB,CAC3C,GAAG;IACF,iBAAiB,CAAC,EAAE,SAAS,CAAC;IAC9B,kBAAkB,CAAC,EAAE,SAAS,CAAC;CAChC,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,WAAW,GAAG,gBAAgB,CAAC;AACzE,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,+BAA+B,GACvC,gBAAgB,CAAC;AACpB,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,sBAAsB,GAC9B,aAAa,CAAC"}

package/lib/typescript/keys/index.d.ts

@@ -0,0 +1,26 @@
+import { AsymmetricKeyObject, CryptoKey, KeyObject, SecretKeyObject, PublicKeyObject, PrivateKeyObject } from './classes';
+import { generateKeyPair, generateKeyPairSync } from './generateKeyPair';
+import { createSign, createVerify, sign, verify, Sign, Verify } from './signVerify';
+import { publicEncrypt, publicDecrypt, privateEncrypt, privateDecrypt } from './publicCipher';
+import { isCryptoKey, parseKeyEncoding, parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+import type { BinaryLike, JWK } from '../utils';
+interface KeyInputObject {
+    key: BinaryLike | KeyObject | CryptoKey | JWK;
+    format?: 'pem' | 'der' | 'jwk' | 'raw-public' | 'raw-private' | 'raw-seed';
+    type?: 'pkcs1' | 'pkcs8' | 'spki' | 'sec1';
+    passphrase?: BinaryLike;
+    encoding?: BufferEncoding;
+    asymmetricKeyType?: string;
+    namedCurve?: string;
+}
+type KeyInput = BinaryLike | KeyInputObject | KeyObject | CryptoKey;
+declare function createSecretKey(key: BinaryLike): SecretKeyObject;
+declare function createPublicKey(key: KeyInput): PublicKeyObject;
+declare function createPrivateKey(key: KeyInput): PrivateKeyObject;
+export interface GenerateKeyOptions {
+    length: number;
+}
+declare function generateKeySync(type: 'aes' | 'hmac', options: GenerateKeyOptions): SecretKeyObject;
+declare function generateKey(type: 'aes' | 'hmac', options: GenerateKeyOptions, callback: (err: Error | null, key?: SecretKeyObject) => void): void;
+export { createSecretKey, createPublicKey, createPrivateKey, CryptoKey, generateKey, generateKeySync, generateKeyPair, generateKeyPairSync, AsymmetricKeyObject, KeyObject, createSign, createVerify, sign, verify, Sign, Verify, publicEncrypt, publicDecrypt, privateEncrypt, privateDecrypt, parsePublicKeyEncoding, parsePrivateKeyEncoding, parseKeyEncoding, SecretKeyObject, PublicKeyObject, PrivateKeyObject, isCryptoKey, };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/keys/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/keys/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,SAAS,EACT,SAAS,EACT,eAAe,EACf,eAAe,EACf,gBAAgB,EACjB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACzE,OAAO,EACL,UAAU,EACV,YAAY,EACZ,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,MAAM,EACP,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,aAAa,EACb,aAAa,EACb,cAAc,EACd,cAAc,EACf,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,UAAU,EAAE,GAAG,EAAmB,MAAM,UAAU,CAAC;AAUjE,UAAU,cAAc;IACtB,GAAG,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,GAAG,CAAC;IAC9C,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,YAAY,GAAG,aAAa,GAAG,UAAU,CAAC;IAC3E,IAAI,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAC3C,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,KAAK,QAAQ,GAAG,UAAU,GAAG,cAAc,GAAG,SAAS,GAAG,SAAS,CAAC;AAsDpE,iBAAS,eAAe,CAAC,GAAG,EAAE,UAAU,GAAG,eAAe,CAGzD;AAwFD,iBAAS,eAAe,CAAC,GAAG,EAAE,QAAQ,GAAG,eAAe,CAmDvD;AAED,iBAAS,gBAAgB,CAAC,GAAG,EAAE,QAAQ,GAAG,gBAAgB,CAqCzD;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,iBAAS,eAAe,CACtB,IAAI,EAAE,KAAK,GAAG,MAAM,EACpB,OAAO,EAAE,kBAAkB,GAC1B,eAAe,CAsCjB;AAED,iBAAS,WAAW,CAClB,IAAI,EAAE,KAAK,GAAG,MAAM,EACpB,OAAO,EAAE,kBAAkB,EAC3B,QAAQ,EAAE,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,CAAC,EAAE,eAAe,KAAK,IAAI,GAC3D,IAAI,CAWN;AAED,OAAO,EAEL,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,SAAS,EACT,WAAW,EACX,eAAe,EACf,eAAe,EACf,mBAAmB,EACnB,mBAAmB,EACnB,SAAS,EACT,UAAU,EACV,YAAY,EACZ,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,MAAM,EACN,aAAa,EACb,aAAa,EACb,cAAc,EACd,cAAc,EAGd,sBAAsB,EACtB,uBAAuB,EACvB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,WAAW,GACZ,CAAC"}

package/lib/typescript/keys/publicCipher.d.ts

@@ -0,0 +1,23 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { BinaryLike } from '../utils';
+import { KeyObject, CryptoKey } from './classes';
+interface PublicCipherOptions {
+    key: BinaryLike | KeyObject | CryptoKey;
+    padding?: number;
+    oaepHash?: string;
+    oaepLabel?: BinaryLike;
+}
+type PublicCipherInput = BinaryLike | KeyObject | CryptoKey | PublicCipherOptions;
+interface PrivateCipherOptions {
+    key: BinaryLike | KeyObject | CryptoKey;
+    padding?: number;
+    oaepHash?: string;
+    oaepLabel?: BinaryLike;
+}
+type PrivateCipherInput = BinaryLike | KeyObject | CryptoKey | PrivateCipherOptions;
+export declare function publicEncrypt(key: PublicCipherInput, buffer: BinaryLike): Buffer;
+export declare function publicDecrypt(key: PublicCipherInput, buffer: BinaryLike): Buffer;
+export declare function privateEncrypt(key: PrivateCipherInput, buffer: BinaryLike): Buffer;
+export declare function privateDecrypt(key: PrivateCipherInput, buffer: BinaryLike): Buffer;
+export {};
+//# sourceMappingURL=publicCipher.d.ts.map

package/lib/typescript/keys/publicCipher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publicCipher.d.ts","sourceRoot":"","sources":["../../../src/keys/publicCipher.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAQ3C,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAGjD,UAAU,mBAAmB;IAC3B,GAAG,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,UAAU,CAAC;CACxB;AAED,KAAK,iBAAiB,GAClB,UAAU,GACV,SAAS,GACT,SAAS,GACT,mBAAmB,CAAC;AAExB,UAAU,oBAAoB;IAC5B,GAAG,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,UAAU,CAAC;CACxB;AAED,KAAK,kBAAkB,GACnB,UAAU,GACV,SAAS,GACT,SAAS,GACT,oBAAoB,CAAC;AA+DzB,wBAAgB,aAAa,CAC3B,GAAG,EAAE,iBAAiB,EACtB,MAAM,EAAE,UAAU,GACjB,MAAM,CAuBR;AAED,wBAAgB,aAAa,CAC3B,GAAG,EAAE,iBAAiB,EACtB,MAAM,EAAE,UAAU,GACjB,MAAM,CAsBR;AAoDD,wBAAgB,cAAc,CAC5B,GAAG,EAAE,kBAAkB,EACvB,MAAM,EAAE,UAAU,GACjB,MAAM,CAiBR;AAED,wBAAgB,cAAc,CAC5B,GAAG,EAAE,kBAAkB,EACvB,MAAM,EAAE,UAAU,GACjB,MAAM,CAwBR"}

package/lib/typescript/keys/signVerify.d.ts

@@ -0,0 +1,35 @@
+import { Buffer } from '@craftzdog/react-native-buffer';
+import { KeyObject, CryptoKey } from './classes';
+import type { BinaryLike } from '../utils';
+type KeyInput = BinaryLike | KeyObject | CryptoKey | KeyInputObject;
+interface KeyInputObject {
+    key: BinaryLike | KeyObject | CryptoKey;
+    format?: 'pem' | 'der';
+    type?: 'pkcs1' | 'pkcs8' | 'spki' | 'sec1';
+    passphrase?: BinaryLike;
+    padding?: number;
+    saltLength?: number;
+    dsaEncoding?: 'der' | 'ieee-p1363';
+}
+export declare class Sign {
+    private handle;
+    constructor(algorithm: string);
+    update(data: BinaryLike): this;
+    sign(privateKey: KeyInput, outputEncoding?: BufferEncoding): Buffer;
+}
+export declare class Verify {
+    private handle;
+    constructor(algorithm: string);
+    update(data: BinaryLike): this;
+    verify(publicKey: KeyInput, signature: BinaryLike, signatureEncoding?: BufferEncoding): boolean;
+}
+export declare function createSign(algorithm: string): Sign;
+export declare function createVerify(algorithm: string): Verify;
+type SignCallback = (err: Error | null, signature?: Buffer) => void;
+type VerifyCallback = (err: Error | null, result?: boolean) => void;
+export declare function sign(algorithm: string | null | undefined, data: BinaryLike, key: KeyInput): Buffer;
+export declare function sign(algorithm: string | null | undefined, data: BinaryLike, key: KeyInput, callback: SignCallback): void;
+export declare function verify(algorithm: string | null | undefined, data: BinaryLike, key: KeyInput, signature: BinaryLike): boolean;
+export declare function verify(algorithm: string | null | undefined, data: BinaryLike, key: KeyInput, signature: BinaryLike, callback: VerifyCallback): void;
+export {};
+//# sourceMappingURL=signVerify.d.ts.map

package/lib/typescript/keys/signVerify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signVerify.d.ts","sourceRoot":"","sources":["../../../src/keys/signVerify.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAC;AAMxD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAEjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAS3C,KAAK,QAAQ,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,cAAc,CAAC;AAEpE,UAAU,cAAc;IACtB,GAAG,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;IACxC,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC;IACvB,IAAI,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAC3C,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,KAAK,GAAG,YAAY,CAAC;CACpC;AAkID,qBAAa,IAAI;IACf,OAAO,CAAC,MAAM,CAAiB;gBAEnB,SAAS,EAAE,MAAM;IAK7B,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAM9B,IAAI,CAAC,UAAU,EAAE,QAAQ,EAAE,cAAc,CAAC,EAAE,cAAc,GAAG,MAAM;CAqBpE;AAED,qBAAa,MAAM;IACjB,OAAO,CAAC,MAAM,CAAmB;gBAErB,SAAS,EAAE,MAAM;IAM7B,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI;IAM9B,MAAM,CACJ,SAAS,EAAE,QAAQ,EACnB,SAAS,EAAE,UAAU,EACrB,iBAAiB,CAAC,EAAE,cAAc,GACjC,OAAO;CAuBX;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAElD;AAED,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AACpE,KAAK,cAAc,GAAG,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;AAEpE,wBAAgB,IAAI,CAClB,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,QAAQ,GACZ,MAAM,CAAC;AACV,wBAAgB,IAAI,CAClB,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,QAAQ,EACb,QAAQ,EAAE,YAAY,GACrB,IAAI,CAAC;AA6BR,wBAAgB,MAAM,CACpB,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,QAAQ,EACb,SAAS,EAAE,UAAU,GACpB,OAAO,CAAC;AACX,wBAAgB,MAAM,CACpB,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACpC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,QAAQ,EACb,SAAS,EAAE,UAAU,EACrB,QAAQ,EAAE,cAAc,GACvB,IAAI,CAAC"}

package/lib/typescript/keys/utils.d.ts

@@ -0,0 +1,51 @@
+import { KeyEncoding, KFormatType } from '../utils';
+import type { CryptoKeyPair, EncodingOptions } from '../utils';
+import type { CryptoKey, PublicKeyObject, PrivateKeyObject } from './classes';
+export declare const isCryptoKey: (obj: any) => boolean;
+export declare function exportPublicKeyRaw(pub: PublicKeyObject, pointType: 'compressed' | 'uncompressed' | undefined): ArrayBuffer;
+export declare function exportPrivateKeyRaw(priv: PrivateKeyObject, format: 'raw-private' | 'raw-seed'): ArrayBuffer;
+export declare function getCryptoKeyPair(key: CryptoKey | CryptoKeyPair): CryptoKeyPair;
+/**
+ * Parses the public key encoding based on an object. keyType must be undefined
+ * when this is used to parse an input encoding and must be a valid key type if
+ * used to parse an output encoding.
+ */
+export declare function parsePublicKeyEncoding(enc: EncodingOptions, keyType: string | undefined, objName?: string): {
+    format: "raw-private" | "raw-seed" | "raw-public";
+    type: KeyEncoding | "compressed" | "uncompressed" | undefined;
+    cipher: undefined;
+    passphrase: undefined;
+} | {
+    format: KFormatType;
+    type: KeyEncoding | "compressed" | "uncompressed" | undefined;
+    cipher: string | undefined;
+    passphrase: ArrayBuffer | undefined;
+};
+/**
+ * Parses the private key encoding based on an object. keyType must be undefined
+ * when this is used to parse an input encoding and must be a valid key type if
+ * used to parse an output encoding.
+ */
+export declare function parsePrivateKeyEncoding(enc: EncodingOptions, keyType: string | undefined, objName?: string): {
+    format: "raw-private" | "raw-seed" | "raw-public";
+    type: KeyEncoding | "compressed" | "uncompressed" | undefined;
+    cipher: undefined;
+    passphrase: undefined;
+} | {
+    format: KFormatType;
+    type: KeyEncoding | "compressed" | "uncompressed" | undefined;
+    cipher: string | undefined;
+    passphrase: ArrayBuffer | undefined;
+};
+export declare function parseKeyEncoding(enc: EncodingOptions, keyType?: string, isPublic?: boolean, objName?: string): {
+    format: "raw-private" | "raw-seed" | "raw-public";
+    type: KeyEncoding | "compressed" | "uncompressed" | undefined;
+    cipher: undefined;
+    passphrase: undefined;
+} | {
+    format: KFormatType;
+    type: KeyEncoding | "compressed" | "uncompressed" | undefined;
+    cipher: string | undefined;
+    passphrase: ArrayBuffer | undefined;
+};
+//# sourceMappingURL=utils.d.ts.map

package/lib/typescript/keys/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/keys/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,WAAW,EACX,WAAW,EACZ,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC/D,OAAO,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAG9E,eAAO,MAAM,WAAW,GAAI,KAAK,GAAG,KAAG,OAEtC,CAAC;AAEF,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,eAAe,EACpB,SAAS,EAAE,YAAY,GAAG,cAAc,GAAG,SAAS,GACnD,WAAW,CAKb;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,aAAa,GAAG,UAAU,GACjC,WAAW,CAQb;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,SAAS,GAAG,aAAa,GAC7B,aAAa,CAGf;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,OAAO,CAAC,EAAE,MAAM;;;;;;;;;;EAGjB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,OAAO,CAAC,EAAE,MAAM;;;;;;;;;;EAGjB;AAED,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,eAAe,EACpB,OAAO,CAAC,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,OAAO,EAClB,OAAO,CAAC,EAAE,MAAM;;;;;;;;;;EAiEjB"}