@symbiote-native/crypto 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,226 @@
+# @symbiote-native/crypto
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-crypto`](https://github.com/expo/expo/tree/main/packages/expo-crypto) — cryptographically
+secure random bytes, `randomUUID`, and string/buffer digest hashing — usable from **every**
+adapter, React, Vue, and Angular, not just React. Like `@symbiote-native/local-auth`, every
+function here is a plain sync/async call with no per-instance state or event stream, so there is
+no hook/composable/service to wrap — the React, Vue, and Angular entry points are plain
+re-exports of the same `core`. AES encryption (`expo-crypto`'s `aes/` subfolder) is out of scope
+for this pass.
+
+## Install
+
+```bash
+npm install @symbiote-native/crypto
+```
+
+`expo-crypto` and `expo-modules-core` come along as regular dependencies, pinned to exact
+versions — never install either yourself, and never add the `expo` meta-package to your project
+(it bundles its own Metro/Babel pipeline, which conflicts with this project's own).
+
+## Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-crypto`'s native code is discovered by
+`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism — this needs wiring
+into the native host app **once**, covering this package and every other `expo-modules-core`
+package with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+
+Full mechanics live in the `symbiote-expo-native-module` project skill. Reference
+implementation: `examples/expo-react/ios/Podfile` and
+`examples/expo-react/android/app/src/main/java/com/canaryexpo/MainApplication.kt`.
+
+No platform permission strings are needed for this package — random-byte generation and
+digest hashing touch no protected device capability.
+
+## Shape
+
+```
+src/core/     getRandomBytes / getRandomBytesAsync / getRandomValues / randomUUID /
+              digestStringAsync / digest, plus CryptoDigestAlgorithm, CryptoEncoding, the
+              option/result types, and the CryptoError validation-error class.
+              native-module.ts resolves the native module via expo-modules-core's
+              requireNativeModule.
+src/react/    @symbiote-native/crypto/react   — export * from '../core'
+src/vue/      @symbiote-native/crypto/vue     — export * from '../core'
+src/angular/  @symbiote-native/crypto/angular — export * from '../core'
+```
+
+No per-adapter lifecycle wrapper exists because there's nothing to subscribe to or clean up —
+each adapter entry is a single-file re-export.
+
+## Use it
+
+```tsx
+// React
+import { useEffect, useState } from 'react';
+import { Pressable, Text, View } from '@symbiote-native/react';
+import {
+  CryptoDigestAlgorithm,
+  digestStringAsync,
+  randomUUID,
+} from '@symbiote-native/crypto/react';
+
+function CryptoScreen() {
+  const [uuid, setUuid] = useState('');
+  const [hash, setHash] = useState('');
+
+  useEffect(() => {
+    setUuid(randomUUID());
+  }, []);
+
+  const handleHash = () => {
+    digestStringAsync(CryptoDigestAlgorithm.SHA256, 'Confirm it is you').then(setHash);
+  };
+
+  return (
+    <View>
+      <Text>UUID: {uuid}</Text>
+      <Pressable onPress={handleHash}>
+        <Text>Hash a string</Text>
+      </Pressable>
+      {hash && <Text>SHA-256: {hash}</Text>}
+    </View>
+  );
+}
+```
+
+```vue
+<!-- Vue -->
+<script setup lang="ts">
+import { onMounted, ref } from 'vue';
+import { Pressable, Text, View } from '@symbiote-native/vue';
+import {
+  CryptoDigestAlgorithm,
+  digestStringAsync,
+  randomUUID,
+} from '@symbiote-native/crypto/vue';
+
+const uuid = ref('');
+const hash = ref('');
+
+onMounted(() => {
+  uuid.value = randomUUID();
+});
+
+function handleHash(): void {
+  void digestStringAsync(CryptoDigestAlgorithm.SHA256, 'Confirm it is you').then(value => {
+    hash.value = value;
+  });
+}
+</script>
+
+<template>
+  <View>
+    <Text>UUID: {{ uuid }}</Text>
+    <Pressable @press="handleHash">
+      <Text>Hash a string</Text>
+    </Pressable>
+    <Text v-if="hash">SHA-256: {{ hash }}</Text>
+  </View>
+</template>
+```
+
+```ts
+// Angular
+import { Component, signal } from '@angular/core';
+import { Pressable, Text, View } from '@symbiote-native/angular';
+import {
+  CryptoDigestAlgorithm,
+  digestStringAsync,
+  randomUUID,
+} from '@symbiote-native/crypto/angular';
+
+@Component({
+  standalone: true,
+  imports: [Pressable, Text, View],
+  template: `
+    <View>
+      <Text>UUID: {{ uuid() }}</Text>
+      <Pressable (press)="handleHash()">
+        <Text>Hash a string</Text>
+      </Pressable>
+      @if (hash()) {
+        <Text>SHA-256: {{ hash() }}</Text>
+      }
+    </View>
+  `,
+})
+export class CryptoScreen {
+  readonly uuid = signal(randomUUID());
+  readonly hash = signal('');
+
+  handleHash(): void {
+    digestStringAsync(CryptoDigestAlgorithm.SHA256, 'Confirm it is you').then(value =>
+      this.hash.set(value),
+    );
+  }
+}
+```
+
+There's no per-instance service to `inject()` in the Angular case — every function is a plain
+free function off the core package.
+
+## API
+
+Free sync/async functions, no event stream, no per-instance state:
+
+```ts
+getRandomBytes(byteCount: number): Uint8Array
+getRandomBytesAsync(byteCount: number): Promise<Uint8Array>
+getRandomValues<T extends ITypedArray>(typedArray: T): T
+randomUUID(): string
+digestStringAsync(
+  algorithm: CryptoDigestAlgorithm,
+  data: string,
+  options?: ICryptoDigestOptions,
+): Promise<IDigest>
+digest(algorithm: CryptoDigestAlgorithm, data: BufferSource): Promise<ArrayBuffer>
+```
+
+Plus `CryptoDigestAlgorithm` (`SHA1`/`SHA256`/`SHA384`/`SHA512`/`MD2`\*/`MD4`\*/`MD5`, \*iOS
+only), `CryptoEncoding` (`HEX`/`BASE64`), `ICryptoDigestOptions`, `IDigest`, `ITypedArray` (and its
+`IUintBasedTypedArray`/`IIntBasedTypedArray` halves), and the `CryptoError` validation-error class
+— ported from upstream's `Crypto.types.ts`/`Crypto.ts`, renamed with this repo's `I`-prefix
+convention for exported types (`ts-js-best-practices`).
+
+```ts
+import { digestStringAsync, randomUUID } from '@symbiote-native/crypto';
+// or the framework-scoped entry points — identical surface, re-exported verbatim:
+import { randomUUID } from '@symbiote-native/crypto/react';
+import { randomUUID } from '@symbiote-native/crypto/vue';
+import { randomUUID } from '@symbiote-native/crypto/angular';
+```
+
+## Notes
+
+- `getRandomBytes`/`getRandomBytesAsync` validate `byteCount` is a number in `0`-`1024`
+  (inclusive), throwing a plain `TypeError` otherwise, and floor a fractional count — matching
+  upstream exactly. This port skips upstream's `__DEV__`/remote-debugger `Math.random` fallback:
+  that's a React Native debugging-tool concern, not applicable to this package's native-call
+  path.
+- `digestStringAsync` validates `algorithm`/`data`/`options.encoding` and throws `CryptoError` (a
+  `TypeError` subclass, `code: 'ERR_CRYPTO'`) on an invalid value — mirroring upstream's own
+  `CryptoError`.
+- `digest` prefers a native `digestAsync` when present; otherwise it allocates a fixed-size
+  output buffer (sized via the `digestLengths` lookup table) and calls the sync native `digest`.
+
+## Test it
+
+No Fabric/Descriptor angle at all — every function here is a pure sync/async-function surface,
+never a view or per-instance state. Tests inject a fake native-module object in place of the
+real `requireNativeModule` resolution (`src/core/crypto.test.ts`, `vitest`) — no
+`installFabric()`, no ViewConfig. Native rendering itself is verified on-device (see the parent
+[README](../../README.md) for the project's testing model).
+
+Native autolinking wiring is expected to land in the four Expo canary apps
+(`examples/expo-react`, `examples/expo-vue-sfc`, `examples/expo-vue-tsx`, `examples/expo-angular`)
+following the same recipe already proven for `@symbiote-native/local-auth`/`@symbiote-native/sensors`
+— demo-screen wiring for this package is a follow-up, not part of this pass.

package/build/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/crypto/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core';

package/build/core/crypto.d.ts

@@ -0,0 +1,37 @@
+import { CryptoDigestAlgorithm } from './types';
+import type { ICryptoDigestOptions, IDigest, ITypedArray } from './types';
+export declare class CryptoError extends TypeError {
+    code: string;
+    constructor(message: string);
+}
+/**
+ * Generates completely random bytes using native implementations. `byteCount` must be within
+ * `0`-`1024` (inclusive), anything else throws a `TypeError`.
+ */
+export declare function getRandomBytes(byteCount: number): Uint8Array;
+/**
+ * Generates completely random bytes using native implementations. `byteCount` must be within
+ * `0`-`1024` (inclusive), anything else throws a `TypeError`.
+ */
+export declare function getRandomBytesAsync(byteCount: number): Promise<Uint8Array>;
+/**
+ * Fills the provided `TypedArray` with cryptographically secure random values in place, and
+ * returns it.
+ */
+export declare function getRandomValues<T extends ITypedArray>(typedArray: T): T;
+/**
+ * Returns a unique identifier based on the V4 UUID spec (RFC4122), using cryptographically
+ * secure random values.
+ */
+export declare function randomUUID(): string;
+/**
+ * Generates a digest of the supplied `data` string with the provided digest `algorithm`,
+ * formatted as one of `CryptoEncoding` (defaults to `HEX`).
+ */
+export declare function digestStringAsync(algorithm: CryptoDigestAlgorithm, data: string, options?: ICryptoDigestOptions): Promise<IDigest>;
+/**
+ * Generates a digest of the supplied `TypedArray`/`ArrayBuffer` of bytes with the provided digest
+ * `algorithm`. Prefers the native async `digestAsync` when present; otherwise falls back to
+ * allocating a fixed-size output buffer (sized via `digestLengths`) and the sync `digest`.
+ */
+export declare function digest(algorithm: CryptoDigestAlgorithm, data: BufferSource): Promise<ArrayBuffer>;

package/build/core/crypto.js

@@ -0,0 +1,132 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoCrypto } from './native-module';
+import { CryptoDigestAlgorithm, CryptoEncoding } from './types';
+const NATIVE_MODULE_NAME = 'expo-crypto';
+const MIN_BYTE_COUNT = 0;
+const MAX_BYTE_COUNT = 1024;
+export class CryptoError extends TypeError {
+    code = 'ERR_CRYPTO';
+    constructor(message) {
+        super(`expo-crypto: ${message}`);
+    }
+}
+function assertByteCount(value, methodName) {
+    if (typeof value !== 'number' ||
+        Number.isNaN(value) ||
+        Math.floor(value) < MIN_BYTE_COUNT ||
+        Math.floor(value) > MAX_BYTE_COUNT) {
+        throw new TypeError(`expo-crypto: ${methodName}(${value}) expected a valid number from range ${MIN_BYTE_COUNT}...${MAX_BYTE_COUNT}`);
+    }
+}
+function assertAlgorithm(algorithm) {
+    if (!Object.values(CryptoDigestAlgorithm).includes(algorithm)) {
+        throw new CryptoError(`Invalid algorithm provided. Expected one of: CryptoDigestAlgorithm.${Object.keys(CryptoDigestAlgorithm).join(', CryptoDigestAlgorithm.')}`);
+    }
+}
+function assertData(data) {
+    if (typeof data !== 'string') {
+        throw new CryptoError('Invalid data provided. Expected a string.');
+    }
+}
+function assertEncoding(encoding) {
+    if (!Object.values(CryptoEncoding).includes(encoding)) {
+        throw new CryptoError(`Invalid encoding provided. Expected one of: CryptoEncoding.${Object.keys(CryptoEncoding).join(', CryptoEncoding.')}`);
+    }
+}
+/**
+ * Generates completely random bytes using native implementations. `byteCount` must be within
+ * `0`-`1024` (inclusive), anything else throws a `TypeError`.
+ */
+export function getRandomBytes(byteCount) {
+    assertByteCount(byteCount, 'getRandomBytes');
+    const validByteCount = Math.floor(byteCount);
+    if (!expoCrypto.getRandomValues) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getRandomBytes');
+    }
+    const byteArray = new Uint8Array(validByteCount);
+    expoCrypto.getRandomValues(byteArray);
+    return byteArray;
+}
+/**
+ * Generates completely random bytes using native implementations. `byteCount` must be within
+ * `0`-`1024` (inclusive), anything else throws a `TypeError`.
+ */
+export async function getRandomBytesAsync(byteCount) {
+    assertByteCount(byteCount, 'getRandomBytesAsync');
+    const validByteCount = Math.floor(byteCount);
+    if (!expoCrypto.getRandomValues) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getRandomBytesAsync');
+    }
+    const byteArray = new Uint8Array(validByteCount);
+    expoCrypto.getRandomValues(byteArray);
+    return byteArray;
+}
+/**
+ * Fills the provided `TypedArray` with cryptographically secure random values in place, and
+ * returns it.
+ */
+export function getRandomValues(typedArray) {
+    if (!expoCrypto.getRandomValues) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getRandomValues');
+    }
+    expoCrypto.getRandomValues(typedArray);
+    return typedArray;
+}
+/**
+ * Returns a unique identifier based on the V4 UUID spec (RFC4122), using cryptographically
+ * secure random values.
+ */
+export function randomUUID() {
+    if (!expoCrypto.randomUUID) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'randomUUID');
+    }
+    return expoCrypto.randomUUID();
+}
+/**
+ * Generates a digest of the supplied `data` string with the provided digest `algorithm`,
+ * formatted as one of `CryptoEncoding` (defaults to `HEX`).
+ */
+export async function digestStringAsync(algorithm, data, options = { encoding: CryptoEncoding.HEX }) {
+    if (!expoCrypto.digestStringAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'digestStringAsync');
+    }
+    assertAlgorithm(algorithm);
+    assertData(data);
+    assertEncoding(options.encoding);
+    return expoCrypto.digestStringAsync(algorithm, data, options);
+}
+// Fixed output length (in bytes) per digest algorithm — used only as the sync fallback's
+// preallocated output buffer size when the native module has no digestAsync.
+const digestLengths = {
+    [CryptoDigestAlgorithm.SHA1]: 20,
+    [CryptoDigestAlgorithm.SHA256]: 32,
+    [CryptoDigestAlgorithm.SHA384]: 48,
+    [CryptoDigestAlgorithm.SHA512]: 64,
+    [CryptoDigestAlgorithm.MD2]: 16,
+    [CryptoDigestAlgorithm.MD4]: 16,
+    [CryptoDigestAlgorithm.MD5]: 16,
+};
+/**
+ * Generates a digest of the supplied `TypedArray`/`ArrayBuffer` of bytes with the provided digest
+ * `algorithm`. Prefers the native async `digestAsync` when present; otherwise falls back to
+ * allocating a fixed-size output buffer (sized via `digestLengths`) and the sync `digest`.
+ */
+export function digest(algorithm, data) {
+    return new Promise((resolve, reject) => {
+        try {
+            if (typeof expoCrypto.digestAsync === 'function') {
+                resolve(expoCrypto.digestAsync(algorithm, data));
+                return;
+            }
+            if (!expoCrypto.digest) {
+                throw new UnavailabilityError(NATIVE_MODULE_NAME, 'digest');
+            }
+            const output = new Uint8Array(digestLengths[algorithm]);
+            expoCrypto.digest(algorithm, output, data);
+            resolve(output.buffer);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export { CryptoError, getRandomBytes, getRandomBytesAsync, getRandomValues, randomUUID, digestStringAsync, digest, } from './crypto';
+export { CryptoDigestAlgorithm, CryptoEncoding, type ICryptoDigestOptions, type IDigest, type IUintBasedTypedArray, type IIntBasedTypedArray, type ITypedArray, } from './types';

package/build/core/index.js

@@ -0,0 +1,2 @@
+export { CryptoError, getRandomBytes, getRandomBytesAsync, getRandomValues, randomUUID, digestStringAsync, digest, } from './crypto';
+export { CryptoDigestAlgorithm, CryptoEncoding, } from './types';

package/build/core/native-module.d.ts

@@ -0,0 +1,9 @@
+import type { CryptoDigestAlgorithm, ICryptoDigestOptions, IDigest, ITypedArray } from './types';
+export type INativeCryptoModule = {
+    getRandomValues(typedArray: ITypedArray): void;
+    randomUUID(): string;
+    digest(algorithm: CryptoDigestAlgorithm, output: Uint8Array, data: BufferSource): void;
+    digestStringAsync?(algorithm: CryptoDigestAlgorithm, data: string, options: ICryptoDigestOptions): Promise<IDigest>;
+    digestAsync?(algorithm: CryptoDigestAlgorithm, data: BufferSource): Promise<ArrayBuffer>;
+};
+export declare const expoCrypto: INativeCryptoModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_CRYPTO_MODULE_NAME = 'ExpoCrypto';
+export const expoCrypto = requireNativeModule(EXPO_CRYPTO_MODULE_NAME);

package/build/core/types.d.ts

@@ -0,0 +1,24 @@
+export declare enum CryptoDigestAlgorithm {
+    SHA1 = "SHA-1",
+    SHA256 = "SHA-256",
+    SHA384 = "SHA-384",
+    SHA512 = "SHA-512",
+    /** @platform ios */
+    MD2 = "MD2",
+    /** @platform ios */
+    MD4 = "MD4",
+    MD5 = "MD5"
+}
+export declare enum CryptoEncoding {
+    HEX = "hex",
+    /** Has trailing padding. Does not wrap lines. Does not have a trailing newline. */
+    BASE64 = "base64"
+}
+export type ICryptoDigestOptions = {
+    /** Format the digest is returned in. */
+    encoding: CryptoEncoding;
+};
+export type IDigest = string;
+export type IUintBasedTypedArray = Uint8Array | Uint16Array | Uint32Array;
+export type IIntBasedTypedArray = Int8Array | Int16Array | Int32Array;
+export type ITypedArray = IUintBasedTypedArray | IIntBasedTypedArray;

package/build/core/types.js

@@ -0,0 +1,18 @@
+export var CryptoDigestAlgorithm;
+(function (CryptoDigestAlgorithm) {
+    CryptoDigestAlgorithm["SHA1"] = "SHA-1";
+    CryptoDigestAlgorithm["SHA256"] = "SHA-256";
+    CryptoDigestAlgorithm["SHA384"] = "SHA-384";
+    CryptoDigestAlgorithm["SHA512"] = "SHA-512";
+    /** @platform ios */
+    CryptoDigestAlgorithm["MD2"] = "MD2";
+    /** @platform ios */
+    CryptoDigestAlgorithm["MD4"] = "MD4";
+    CryptoDigestAlgorithm["MD5"] = "MD5";
+})(CryptoDigestAlgorithm || (CryptoDigestAlgorithm = {}));
+export var CryptoEncoding;
+(function (CryptoEncoding) {
+    CryptoEncoding["HEX"] = "hex";
+    /** Has trailing padding. Does not wrap lines. Does not have a trailing newline. */
+    CryptoEncoding["BASE64"] = "base64";
+})(CryptoEncoding || (CryptoEncoding = {}));

package/build/react/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/react/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/crypto/react: the React entry over the framework-agnostic core.
+// Upstream ships free sync/async functions and two enums, no per-instance state and no event
+// stream — there is nothing for a hook to wrap, so this is a plain re-export, mirroring
+// packages/local-auth/src/react/index.ts.
+export * from '../core';

package/build/vue/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/vue/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/crypto/vue: the Vue entry over the framework-agnostic core. Same reasoning
+// as the React entry — no per-instance state or event stream to wire onto Vue's reactivity, so
+// this is a plain re-export.
+export * from '../core';

package/build-ngc/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/crypto/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,0FAA0F;AAC1F,yCAAyC;AACzC,cAAc,SAAS,CAAC"}

package/build-ngc/core/crypto.d.ts

@@ -0,0 +1,37 @@
+import { CryptoDigestAlgorithm } from './types';
+import type { ICryptoDigestOptions, IDigest, ITypedArray } from './types';
+export declare class CryptoError extends TypeError {
+    code: string;
+    constructor(message: string);
+}
+/**
+ * Generates completely random bytes using native implementations. `byteCount` must be within
+ * `0`-`1024` (inclusive), anything else throws a `TypeError`.
+ */
+export declare function getRandomBytes(byteCount: number): Uint8Array;
+/**
+ * Generates completely random bytes using native implementations. `byteCount` must be within
+ * `0`-`1024` (inclusive), anything else throws a `TypeError`.
+ */
+export declare function getRandomBytesAsync(byteCount: number): Promise<Uint8Array>;
+/**
+ * Fills the provided `TypedArray` with cryptographically secure random values in place, and
+ * returns it.
+ */
+export declare function getRandomValues<T extends ITypedArray>(typedArray: T): T;
+/**
+ * Returns a unique identifier based on the V4 UUID spec (RFC4122), using cryptographically
+ * secure random values.
+ */
+export declare function randomUUID(): string;
+/**
+ * Generates a digest of the supplied `data` string with the provided digest `algorithm`,
+ * formatted as one of `CryptoEncoding` (defaults to `HEX`).
+ */
+export declare function digestStringAsync(algorithm: CryptoDigestAlgorithm, data: string, options?: ICryptoDigestOptions): Promise<IDigest>;
+/**
+ * Generates a digest of the supplied `TypedArray`/`ArrayBuffer` of bytes with the provided digest
+ * `algorithm`. Prefers the native async `digestAsync` when present; otherwise falls back to
+ * allocating a fixed-size output buffer (sized via `digestLengths`) and the sync `digest`.
+ */
+export declare function digest(algorithm: CryptoDigestAlgorithm, data: BufferSource): Promise<ArrayBuffer>;