@upstash/qstash 0.0.9 → 0.0.12

package/script/pkg/client/endpoints.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Endpoints = void 0;
+class Endpoints {
+    constructor(http) {
+        Object.defineProperty(this, "http", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.http = http;
+    }
+    /**
+     * Create a new endpoint with the given name.
+     */
+    async create(req) {
+        return await this.http.request({
+            method: "POST",
+            path: ["v1", "endpoints"],
+            body: JSON.stringify(req),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Get a list of all endpoints.
+     */
+    async list() {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "endpoints"],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Get a single endpoint.
+     */
+    async get(req) {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "endpoints", req.id],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Update a endpoint
+     */
+    async update(req) {
+        return await this.http.request({
+            method: "PUT",
+            path: ["v1", "endpoints", req.id],
+            body: JSON.stringify({ url: req.url }),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Delete a endpoint.
+     */
+    async delete(req) {
+        return await this.http.request({
+            method: "DELETE",
+            path: ["v1", "endpoints", req.id],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+}
+exports.Endpoints = Endpoints;

package/script/pkg/client/error.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QstashError = void 0;
+/**
+ * Result of 500 Internal Server Error
+ */
+class QstashError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "QstashError";
+    }
+}
+exports.QstashError = QstashError;

package/script/pkg/client/http.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const error_js_1 = require("./error.js");
+class HttpClient {
+    constructor(config) {
+        Object.defineProperty(this, "baseUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "authorization", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "retry", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.baseUrl = config.baseUrl.replace(/\/$/, "");
+        this.authorization = config.authorization;
+        if (typeof config?.retry === "boolean" && config?.retry === false) {
+            this.retry = {
+                attempts: 1,
+                backoff: () => 0,
+            };
+        }
+        else {
+            this.retry = {
+                attempts: config?.retry?.retries ?? 5,
+                backoff: config?.retry?.backoff ??
+                    ((retryCount) => Math.exp(retryCount) * 50),
+            };
+        }
+    }
+    async request(req) {
+        const headers = new Headers(req.headers);
+        headers.set("Upstash-Authorization", `Bearer ${this.authorization}`);
+        const requestOptions = {
+            method: req.method,
+            headers,
+            body: req.body,
+            keepalive: req.keepalive,
+        };
+        const url = new URL([this.baseUrl, ...(req.path ?? [])].join("/"));
+        if (req.query) {
+            for (const [key, value] of Object.entries(req.query)) {
+                if (typeof value !== "undefined") {
+                    url.searchParams.set(key, value.toString());
+                }
+            }
+        }
+        let res = null;
+        let error = null;
+        for (let i = 0; i <= this.retry.attempts; i++) {
+            try {
+                res = await fetch(url.toString(), requestOptions);
+                break;
+            }
+            catch (err) {
+                error = err;
+                await new Promise((r) => setTimeout(r, this.retry.backoff(i)));
+            }
+        }
+        if (!res) {
+            throw error ?? new Error("Exhausted all retries");
+        }
+        if (res.status < 200 || res.status >= 300) {
+            throw new error_js_1.QstashError(await res.text() ?? res.statusText);
+        }
+        return (await res.json());
+    }
+}
+exports.HttpClient = HttpClient;

package/script/pkg/client/messages.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Messages = void 0;
+class Messages {
+    constructor(http) {
+        Object.defineProperty(this, "http", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.http = http;
+    }
+    /**
+     * Get a message
+     */
+    async get(req) {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "messages", req.id],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * List your messages
+     */
+    async list(req) {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "messages"],
+            headers: { "Content-Type": "application/json" },
+            query: { cursor: req?.cursor },
+        });
+    }
+    /**
+     * List logs from a message
+     */
+    async logs(req) {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "messages", req.id, "logs"],
+            headers: { "Content-Type": "application/json" },
+            query: { cursor: req.cursor },
+        });
+    }
+    /**
+     * List tasks for a message
+     */
+    async tasks(req) {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "messages", req.id, "tasks"],
+            headers: { "Content-Type": "application/json" },
+            query: { cursor: req.cursor },
+        });
+    }
+    /**
+     * Cancel a topic by name or id.
+     */
+    async delete(req) {
+        return await this.http.request({
+            method: "DELETE",
+            path: ["v1", "messages", req.id],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+}
+exports.Messages = Messages;

package/script/pkg/client/schedules.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schedules = void 0;
+class Schedules {
+    constructor(http) {
+        Object.defineProperty(this, "http", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.http = http;
+    }
+    /**
+     * Get a schedule
+     */
+    async get(req) {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "schedules", req.id],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * List your schedules
+     */
+    async list() {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "schedules"],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Delete a schedule
+     */
+    async delete(req) {
+        return await this.http.request({
+            method: "DELETE",
+            path: ["v1", "schedules", req.id],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+}
+exports.Schedules = Schedules;

package/script/pkg/client/topics.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Topics = void 0;
+class Topics {
+    constructor(http) {
+        Object.defineProperty(this, "http", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.http = http;
+    }
+    /**
+     * Create a new topic with the given name.
+     */
+    async create(req) {
+        return await this.http.request({
+            method: "POST",
+            path: ["v1", "topics"],
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: req.name }),
+        });
+    }
+    /**
+     * Get a list of all topics.
+     */
+    async list() {
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "topics"],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Get a single topic by name or id.
+     */
+    async get(req) {
+        const idOrName = req.id ?? req.name;
+        if (!idOrName) {
+            throw new Error("Either id or name must be provided");
+        }
+        return await this.http.request({
+            method: "GET",
+            path: ["v1", "topics", idOrName],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Update a topic
+     */
+    async update(req) {
+        return await this.http.request({
+            method: "PUT",
+            path: ["v1", "topics", req.id],
+            body: JSON.stringify({ name: req.name }),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    /**
+     * Delete a topic by name or id.
+     */
+    async delete(req) {
+        const idOrName = req.id ?? req.name;
+        if (!idOrName) {
+            throw new Error("Either id or name must be provided");
+        }
+        return await this.http.request({
+            method: "DELETE",
+            path: ["v1", "topics", idOrName],
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+}
+exports.Topics = Topics;

package/script/pkg/client/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/{consumer.js → pkg/consumer.js}

@@ -1,31 +1,7 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Consumer = exports.SignatureError = void 0;
-const dntShim = __importStar(require("./_dnt.shims.js"));
-const base64url = __importStar(require("./deps/deno.land/std@0.144.0/encoding/base64url.js"));
+const deps_js_1 = require("../deps.js");
 class SignatureError extends Error {
     constructor(message) {
         super(message);
@@ -50,8 +26,15 @@ class Consumer {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "subtleCrypto", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.currentSigningKey = config.currentSigningKey;
         this.nextSigningKey = config.nextSigningKey;
+        this.subtleCrypto = config.subtleCrypto;
     }
     /**
      * Verify the signature of a request.
@@ -78,12 +61,12 @@ class Consumer {
             throw new SignatureError("`Upstash-Signature` header is not a valid signature");
         }
         const [header, payload, signature] = parts;
-        const k = await dntShim.crypto.subtle.importKey("raw", new TextEncoder().encode(key), { name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"]);
-        const isValid = await dntShim.crypto.subtle.verify({ name: "HMAC" }, k, base64url.decode(signature), new TextEncoder().encode(`${header}.${payload}`));
+        const k = await this.subtleCrypto.importKey("raw", new TextEncoder().encode(key), { name: "HMAC", hash: "SHA-256" }, false, ["sign", "verify"]);
+        const isValid = await this.subtleCrypto.verify({ name: "HMAC" }, k, deps_js_1.base64Url.decode(signature), new TextEncoder().encode(`${header}.${payload}`));
         if (!isValid) {
             throw new SignatureError("signature does not match");
         }
-        const p = JSON.parse(new TextDecoder().decode(base64url.decode(payload)));
+        const p = JSON.parse(new TextDecoder().decode(deps_js_1.base64Url.decode(payload)));
         console.log(JSON.stringify(p, null, 2));
         if (p.iss !== "Upstash") {
             throw new SignatureError(`invalid issuer: ${p.iss}`);
@@ -99,9 +82,13 @@ class Consumer {
         if (now < p.nbf) {
             throw new SignatureError("token is not yet valid");
         }
-        const bodyHash = await dntShim.crypto.subtle.digest("SHA-256", new TextEncoder().encode(req.body));
-        if (p.body != base64url.encode(bodyHash)) {
-            throw new SignatureError(`body hash does not match, want: ${p.body}, got: ${base64url.encode(bodyHash)}`);
+        const bodyHash = await this.subtleCrypto.digest("SHA-256", typeof req.body === "string"
+            ? new TextEncoder().encode(req.body)
+            : req.body);
+        const padding = new RegExp(/=+$/);
+        if (p.body.replace(padding, "") !=
+            deps_js_1.base64Url.encode(bodyHash).replace(padding, "")) {
+            throw new SignatureError(`body hash does not match, want: ${p.body}, got: ${deps_js_1.base64Url.encode(bodyHash)}`);
         }
         return true;
     }

package/types/_dnt.shims.d.ts

@@ -1,7 +1,4 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
 export { crypto, type Crypto, type SubtleCrypto, type AlgorithmIdentifier, type Algorithm, type RsaOaepParams, type BufferSource, type AesCtrParams, type AesCbcParams, type AesGcmParams, type CryptoKey, type KeyAlgorithm, type KeyType, type KeyUsage, type EcdhKeyDeriveParams, type HkdfParams, type HashAlgorithmIdentifier, type Pbkdf2Params, type AesDerivedKeyParams, type HmacImportParams, type JsonWebKey, type RsaOtherPrimesInfo, type KeyFormat, type RsaHashedKeyGenParams, type RsaKeyGenParams, type BigInteger, type EcKeyGenParams, type NamedCurve, type CryptoKeyPair, type AesKeyGenParams, type HmacKeyGenParams, type RsaHashedImportParams, type EcKeyImportParams, type AesKeyAlgorithm, type RsaPssParams, type EcdsaParams } from "@deno/shim-crypto";
-export declare const dntGlobalThis: Omit<typeof globalThis, "crypto" | "Deno"> & {
-    Deno: typeof Deno;
+export declare const dntGlobalThis: Omit<typeof globalThis, "crypto"> & {
     crypto: import("@deno/shim-crypto").Crypto;
 };

package/types/deps/deno.land/std@0.147.0/_wasm_crypto/lib/deno_std_wasm_crypto.generated.d.mts

@@ -0,0 +1,125 @@
+/**
+ * Returns the digest of the given `data` using the given hash `algorithm`.
+ *
+ * `length` will usually be left `undefined` to use the default length for
+ * the algorithm. For algorithms with variable-length output, it can be used
+ * to specify a non-negative integer number of bytes.
+ *
+ * An error will be thrown if `algorithm` is not a supported hash algorithm or
+ * `length` is not a supported length for the algorithm.
+ * @param {string} algorithm
+ * @param {Uint8Array} data
+ * @param {number | undefined} length
+ * @returns {Uint8Array}
+ */
+export function digest(algorithm: string, data: Uint8Array, length: number | undefined): Uint8Array;
+/** Instantiates an instance of the Wasm module returning its functions.
+ * @remarks It is safe to call this multiple times and once successfully
+ * loaded it will always return a reference to the same object.
+ */
+export function instantiate(): {
+    digest: typeof digest;
+    DigestContext: typeof DigestContext;
+};
+/** Instantiates an instance of the Wasm module along with its exports.
+ * @remarks It is safe to call this multiple times and once successfully
+ * loaded it will always return a reference to the same object.
+ * @returns {{
+ *   instance: WebAssembly.Instance;
+ *   exports: { digest: typeof digest; DigestContext : typeof DigestContext  }
+ * }}
+ */
+export function instantiateWithInstance(): {
+    instance: WebAssembly.Instance;
+    exports: {
+        digest: typeof digest;
+        DigestContext: typeof DigestContext;
+    };
+};
+/** Gets if the Wasm module has been instantiated. */
+export function isInstantiated(): boolean;
+/**
+ * A context for incrementally computing a digest using a given hash algorithm.
+ */
+export class DigestContext {
+    static __wrap(ptr: any): any;
+    /**
+     * Creates a new context incrementally computing a digest using the given
+     * hash algorithm.
+     *
+     * An error will be thrown if `algorithm` is not a supported hash algorithm.
+     * @param {string} algorithm
+     */
+    constructor(algorithm: string);
+    __destroy_into_raw(): number | undefined;
+    ptr: number | undefined;
+    free(): void;
+    /**
+     * Update the digest's internal state with the additional input `data`.
+     *
+     * If the `data` array view is large, it will be split into subarrays (via
+     * JavaScript bindings) which will be processed sequentially in order to
+     * limit the amount of memory that needs to be allocated in the Wasm heap.
+     * @param {Uint8Array} data
+     */
+    update(data: Uint8Array): void;
+    /**
+     * Returns the digest of the input data so far. This may be called repeatedly
+     * without side effects.
+     *
+     * `length` will usually be left `undefined` to use the default length for
+     * the algorithm. For algorithms with variable-length output, it can be used
+     * to specify a non-negative integer number of bytes.
+     *
+     * An error will be thrown if `algorithm` is not a supported hash algorithm or
+     * `length` is not a supported length for the algorithm.
+     * @param {number | undefined} length
+     * @returns {Uint8Array}
+     */
+    digest(length: number | undefined): Uint8Array;
+    /**
+     * Returns the digest of the input data so far, and resets this context to
+     * its initial state, as though it has not yet been provided with any input
+     * data. (It will still use the same algorithm.)
+     *
+     * `length` will usually be left `undefined` to use the default length for
+     * the algorithm. For algorithms with variable-length output, it can be used
+     * to specify a non-negative integer number of bytes.
+     *
+     * An error will be thrown if `algorithm` is not a supported hash algorithm or
+     * `length` is not a supported length for the algorithm.
+     * @param {number | undefined} length
+     * @returns {Uint8Array}
+     */
+    digestAndReset(length: number | undefined): Uint8Array;
+    /**
+     * Returns the digest of the input data so far, and then drops the context
+     * from memory on the Wasm side. This context must no longer be used, and any
+     * further method calls will result in null pointer errors being thrown.
+     * https://github.com/rustwasm/wasm-bindgen/blob/bf39cfd8/crates/backend/src/codegen.rs#L186
+     *
+     * `length` will usually be left `undefined` to use the default length for
+     * the algorithm. For algorithms with variable-length output, it can be used
+     * to specify a non-negative integer number of bytes.
+     *
+     * An error will be thrown if `algorithm` is not a supported hash algorithm or
+     * `length` is not a supported length for the algorithm.
+     * @param {number | undefined} length
+     * @returns {Uint8Array}
+     */
+    digestAndDrop(length: number | undefined): Uint8Array;
+    /**
+     * Resets this context to its initial state, as though it has not yet been
+     * provided with any input data. (It will still use the same algorithm.)
+     */
+    reset(): void;
+    /**
+     * Returns a new `DigestContext` that is a copy of this one, i.e., using the
+     * same algorithm and with a copy of the same internal state.
+     *
+     * This may be a more efficient option for computing multiple digests that
+     * start with a common prefix.
+     * @returns {DigestContext}
+     */
+    clone(): DigestContext;
+}

package/types/deps/deno.land/std@0.147.0/_wasm_crypto/mod.d.ts

@@ -0,0 +1,12 @@
+export { DigestContext, instantiate as instantiateWasm, } from "./lib/deno_std_wasm_crypto.generated.js";
+/**
+ * All cryptographic hash/digest algorithms supported by std/_wasm_crypto.
+ *
+ * For algorithms that are supported by WebCrypto, the name here must match the
+ * one used by WebCrypto. Otherwise we should prefer the formatting used in the
+ * official specification. All names are uppercase to facilitate case-insensitive
+ * comparisons required by the WebCrypto spec.
+ */
+export declare const digestAlgorithms: readonly ["BLAKE2B-256", "BLAKE2B-384", "BLAKE2B", "BLAKE2S", "BLAKE3", "KECCAK-224", "KECCAK-256", "KECCAK-384", "KECCAK-512", "SHA-384", "SHA3-224", "SHA3-256", "SHA3-384", "SHA3-512", "SHAKE128", "SHAKE256", "TIGER", "RIPEMD-160", "SHA-224", "SHA-256", "SHA-512", "MD4", "MD5", "SHA-1"];
+/** An algorithm name supported by std/_wasm_crypto. */
+export declare type DigestAlgorithm = typeof digestAlgorithms[number];

package/types/deps/deno.land/std@0.147.0/crypto/_fnv/fnv32.d.ts

@@ -0,0 +1,2 @@
+export declare const fnv32: (data: Uint8Array) => ArrayBuffer;
+export declare const fnv32a: (data: Uint8Array) => ArrayBuffer;

package/types/deps/deno.land/std@0.147.0/crypto/_fnv/fnv64.d.ts

@@ -0,0 +1,2 @@
+export declare const fnv64: (data: Uint8Array) => ArrayBuffer;
+export declare const fnv64a: (data: Uint8Array) => ArrayBuffer;

package/types/deps/deno.land/std@0.147.0/crypto/_fnv/index.d.ts

@@ -0,0 +1 @@
+export declare const fnv: (name: string, buf: Uint8Array | undefined) => ArrayBuffer;

package/types/deps/deno.land/std@0.147.0/crypto/_fnv/util.d.ts

@@ -0,0 +1,13 @@
+export declare function swap32(val: number): number;
+/**
+ * mul32 performs 32-bit multiplication, a * b
+ * @param a
+ * @param b
+ */
+export declare function mul32(a: number, b: number): number;
+/**
+ * mul64 performs 64-bit multiplication with two 32-bit words
+ * @param [ah, al]
+ * @param [bh, bl]
+ */
+export declare function mul64([ah, al]: [number, number], [bh, bl]: [number, number]): [number, number];

package/types/deps/deno.land/std@0.147.0/crypto/mod.d.ts

@@ -0,0 +1,53 @@
+import * as dntShim from "../../../../_dnt.shims.js";
+import { DigestAlgorithm as WasmDigestAlgorithm } from "../_wasm_crypto/mod.js";
+/**
+ * An wrapper for WebCrypto adding support for additional non-standard
+ * algorithms, but delegating to the runtime WebCrypto implementation whenever
+ * possible.
+ */
+declare const stdCrypto: {
+    subtle: {
+        /**
+         * Returns a new `Promise` object that will digest `data` using the specified
+         * `AlgorithmIdentifier`.
+         */
+        digest(algorithm: DigestAlgorithm, data: dntShim.BufferSource | AsyncIterable<dntShim.BufferSource> | Iterable<dntShim.BufferSource>): Promise<ArrayBuffer>;
+        /**
+         * Returns a ArrayBuffer with the result of digesting `data` using the
+         * specified `AlgorithmIdentifier`.
+         */
+        digestSync(algorithm: DigestAlgorithm, data: dntShim.BufferSource | Iterable<dntShim.BufferSource>): ArrayBuffer;
+        decrypt: (algorithm: dntShim.AlgorithmIdentifier | dntShim.RsaOaepParams | dntShim.AesCtrParams | dntShim.AesCbcParams | dntShim.AesGcmParams, key: dntShim.CryptoKey, data: dntShim.BufferSource) => Promise<any>;
+        deriveBits: (algorithm: dntShim.AlgorithmIdentifier | dntShim.EcdhKeyDeriveParams | dntShim.HkdfParams | dntShim.Pbkdf2Params, baseKey: dntShim.CryptoKey, length: number) => Promise<ArrayBuffer>;
+        deriveKey: (algorithm: dntShim.AlgorithmIdentifier | dntShim.EcdhKeyDeriveParams | dntShim.HkdfParams | dntShim.Pbkdf2Params, baseKey: dntShim.CryptoKey, derivedKeyType: dntShim.AlgorithmIdentifier | dntShim.HkdfParams | dntShim.Pbkdf2Params | dntShim.AesDerivedKeyParams | dntShim.HmacImportParams, extractable: boolean, keyUsages: dntShim.KeyUsage[]) => Promise<dntShim.CryptoKey>;
+        encrypt: (algorithm: dntShim.AlgorithmIdentifier | dntShim.RsaOaepParams | dntShim.AesCtrParams | dntShim.AesCbcParams | dntShim.AesGcmParams, key: dntShim.CryptoKey, data: dntShim.BufferSource) => Promise<any>;
+        exportKey: {
+            (format: "jwk", key: dntShim.CryptoKey): Promise<dntShim.JsonWebKey>;
+            (format: "pkcs8" | "raw" | "spki", key: dntShim.CryptoKey): Promise<ArrayBuffer>;
+        };
+        generateKey: {
+            (algorithm: dntShim.RsaHashedKeyGenParams | dntShim.EcKeyGenParams, extractable: boolean, keyUsages: readonly dntShim.KeyUsage[]): Promise<dntShim.CryptoKeyPair>;
+            (algorithm: dntShim.Pbkdf2Params | dntShim.AesKeyGenParams | dntShim.HmacKeyGenParams, extractable: boolean, keyUsages: readonly dntShim.KeyUsage[]): Promise<dntShim.CryptoKey>;
+            (algorithm: dntShim.AlgorithmIdentifier, extractable: boolean, keyUsages: dntShim.KeyUsage[]): Promise<dntShim.CryptoKey | dntShim.CryptoKeyPair>;
+        };
+        importKey: {
+            (format: "jwk", keyData: dntShim.JsonWebKey, algorithm: dntShim.AlgorithmIdentifier | dntShim.HmacImportParams | dntShim.RsaHashedImportParams | dntShim.EcKeyImportParams | dntShim.AesKeyAlgorithm, extractable: boolean, keyUsages: readonly dntShim.KeyUsage[]): Promise<dntShim.CryptoKey>;
+            (format: "pkcs8" | "raw" | "spki", keyData: dntShim.BufferSource, algorithm: dntShim.AlgorithmIdentifier | dntShim.HmacImportParams | dntShim.RsaHashedImportParams | dntShim.EcKeyImportParams | dntShim.AesKeyAlgorithm, extractable: boolean, keyUsages: dntShim.KeyUsage[]): Promise<dntShim.CryptoKey>;
+        };
+        sign: (algorithm: dntShim.AlgorithmIdentifier | dntShim.RsaPssParams | dntShim.EcdsaParams, key: dntShim.CryptoKey, data: dntShim.BufferSource) => Promise<ArrayBuffer>;
+        unwrapKey: (format: dntShim.KeyFormat, wrappedKey: dntShim.BufferSource, unwrappingKey: dntShim.CryptoKey, unwrapAlgorithm: dntShim.AlgorithmIdentifier | dntShim.RsaOaepParams | dntShim.AesCtrParams | dntShim.AesCbcParams | dntShim.AesGcmParams, unwrappedKeyAlgorithm: dntShim.AlgorithmIdentifier | dntShim.HmacImportParams | dntShim.RsaHashedImportParams | dntShim.EcKeyImportParams | dntShim.AesKeyAlgorithm, extractable: boolean, keyUsages: dntShim.KeyUsage[]) => Promise<dntShim.CryptoKey>;
+        verify: (algorithm: dntShim.AlgorithmIdentifier | dntShim.RsaPssParams | dntShim.EcdsaParams, key: dntShim.CryptoKey, signature: dntShim.BufferSource, data: dntShim.BufferSource) => Promise<boolean>;
+        wrapKey: (format: dntShim.KeyFormat, key: dntShim.CryptoKey, wrappingKey: dntShim.CryptoKey, wrapAlgorithm: dntShim.AlgorithmIdentifier | dntShim.RsaOaepParams | dntShim.AesCtrParams | dntShim.AesCbcParams | dntShim.AesGcmParams) => Promise<ArrayBuffer>;
+    };
+    getRandomValues: <T extends ArrayBufferView | null>(array: T) => T;
+    randomUUID: () => string;
+};
+declare const FNVAlgorithms: string[];
+declare type FNVAlgorithms = "FNV32" | "FNV32A" | "FNV64" | "FNV64A";
+declare type DigestAlgorithmName = WasmDigestAlgorithm | FNVAlgorithms;
+declare type DigestAlgorithmObject = {
+    name: DigestAlgorithmName;
+    length?: number;
+};
+declare type DigestAlgorithm = DigestAlgorithmName | DigestAlgorithmObject;
+export { stdCrypto as crypto };