@upstash/qstash 0.0.10 → 0.0.13

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 };

package/types/deps/deno.land/{std@0.144.0 → std@0.147.0}/encoding/base64url.d.ts

@@ -1,4 +1,3 @@
-export declare function addPaddingToBase64url(base64url: string): string;
 /**
  * Encodes a given ArrayBuffer or string into a base64url representation
  * @param data

package/types/deps.d.ts

@@ -0,0 +1 @@
+export * as base64Url from "./deps/deno.land/std@0.147.0/encoding/base64url.js";

package/types/entrypoints/cloudflare.d.ts

@@ -0,0 +1,5 @@
+import * as c from "../pkg/consumer.js";
+export * from "../pkg/client/client.js";
+export declare class Consumer extends c.Consumer {
+    constructor(config: Omit<c.ConsumerConfig, "crypto">);
+}

package/types/entrypoints/nextjs.d.ts

@@ -2,5 +2,11 @@ import type { NextApiHandler } from "next";
 export declare type VerifySignaturConfig = {
     currentSigningKey?: string;
     nextSigningKey?: string;
+    /**
+     * The url of this api route, including the protocol.
+     *
+     * If you omit this, the url will be automatically determined by checking the `VERCEL_URL` env variable and assuming `https`
+     */
+    url?: string;
 };
 export declare function verifySignature(handler: NextApiHandler, config?: VerifySignaturConfig): NextApiHandler;

package/types/entrypoints/nodejs.d.ts

@@ -0,0 +1,5 @@
+import * as c from "../pkg/consumer.js";
+export * from "../pkg/client/client.js";
+export declare class Consumer extends c.Consumer {
+    constructor(config: Omit<c.ConsumerConfig, "crypto">);
+}

package/types/pkg/client/client.d.ts

@@ -0,0 +1,193 @@
+import { Requester } from "./http.js";
+import { Topics } from "./topics.js";
+import { Messages } from "./messages.js";
+import { Schedules } from "./schedules.js";
+import { Endpoints } from "./endpoints.js";
+import type { Log } from "./types.js";
+import type { BodyInit, HeadersInit } from "../../deps/raw.githubusercontent.com/microsoft/TypeScript/main/lib/lib.dom";
+export declare type ClientConfig = {
+    /**
+     * Url of the qstash api server.
+     *
+     * This is only used for testing.
+     *
+     * @default "https://qstash.upstash.io"
+     */
+    baseUrl?: string;
+    /**
+     * The authorization token from the upstash console.
+     */
+    token: string;
+};
+declare type Destination = {
+    /**
+     * The url of a publicly accessible server where you want to send this message to.
+     * The url must have a valid scheme (http or https).
+     */
+    url: string;
+    topic?: never;
+} | {
+    url?: never;
+    /**
+     * Either the name or id of a topic to send this message to.
+     */
+    topic: string;
+};
+export declare type PublishRequest = Destination & {
+    /**
+     * The message to send.
+     *
+     * This can be anything, but please set the `Content-Type` header accordingly.
+     *
+     * You can leave this empty if you want to send a message with no body.
+     */
+    body?: BodyInit;
+    /**
+     * Optionally send along headers with the message.
+     * These headers will be sent to your destination.
+     *
+     * We highly recommend sending a `Content-Type` header along, as this will help your destination
+     * server to understand the content of the message.
+     */
+    headers?: HeadersInit;
+    /**
+     * Optionally delay the delivery of this message.
+     *
+     * In seconds.
+     *
+     * @default undefined
+     */
+    delay?: number;
+    /**
+     * Optionally set the absolute delay of this message.
+     * This will override the delay option.
+     * The message will not delivered until the specified time.
+     *
+     * Unix timestamp in seconds.
+     *
+     * @default undefined
+     */
+    notBefore?: number;
+    /**
+     * Provide a unique id for deduplication. This id will be used to detect duplicate messages.
+     * If a duplicate message is detected, the request will be accepted but not enqueued.
+     *
+     * We store deduplication ids for 90 days. Afterwards it is possible that the message with the
+     * same deduplication id is delivered again.
+     *
+     * When scheduling a message, the deduplication happens before the schedule is created.
+     *
+     * @default undefined
+     */
+    deduplicationId?: string;
+    /**
+     * If true, the message content will get hashed and used as deduplication id.
+     * If a duplicate message is detected, the request will be accepted but not enqueued.
+     *
+     * The content based hash includes the following values:
+     *    - All headers, except Upstash-Authorization, this includes all headers you are sending.
+     *    - The entire raw request body The destination from the url path
+     *
+     * We store deduplication ids for 90 days. Afterwards it is possible that the message with the
+     * same deduplication id is delivered again.
+     *
+     * When scheduling a message, the deduplication happens before the schedule is created.
+     *
+     * @default false
+     */
+    contentBasedDeduplication?: boolean;
+    /**
+     * In case your destination server is unavaialble or returns a status code outside of the 200-299
+     * range, we will retry the request after a certain amount of time.
+     *
+     * Configure how many times you would like the delivery to be retried
+     *
+     * @default The maximum retry quota associated with your account.
+     */
+    retries?: number;
+} & ({
+    /**
+     * Optionally specify a cron expression to repeatedly send this message to the destination.
+     *
+     * @default undefined
+     */
+    cron: string;
+} | {
+    cron?: never;
+});
+export declare type PublishJsonRequest = Omit<PublishRequest, "body"> & {
+    /**
+     * The message to send.
+     * This can be anything as long as it can be serialized to JSON.
+     */
+    body: unknown;
+};
+export declare type LogsRequest = {
+    cursor?: number;
+};
+export declare type GetLogsRespone = {
+    cursor?: number;
+    logs: Log[];
+};
+export declare class Client {
+    http: Requester;
+    constructor(config: ClientConfig);
+    /**
+     * Access the topic API.
+     *
+     * Create, read, update or delete topics.
+     */
+    get topics(): Topics;
+    /**
+     * Access the endpoint API.
+     *
+     * Create, read, update or delete endpoints.
+     */
+    get endpoints(): Endpoints;
+    /**
+     * Access the message API.
+     *
+     * Read or cancel messages.
+     */
+    get messages(): Messages;
+    /**
+     * Access the schedule API.
+     *
+     * Read or delete schedules.
+     */
+    get schedules(): Schedules;
+    publish<R extends PublishRequest>(req: R): Promise<PublishResponse<R>>;
+    /**
+     * publishJSON is a utility wrapper around `publish` that automatically serializes the body
+     * and sets the `Content-Type` header to `application/json`.
+     */
+    publishJSON<R extends PublishJsonRequest = PublishJsonRequest>(req: R): Promise<PublishResponse<R>>;
+    /**
+     * Retrieve your logs.
+     *
+     * The logs endpoint is paginated and returns only 100 logs at a time.
+     * If you want to receive more logs, you can use the cursor to paginate.
+     *
+     * The cursor is a unix timestamp with millisecond precision
+     *
+     * @example
+     * ```ts
+     * let cursor = Date.now()
+     * const logs: Log[] = []
+     * while (cursor > 0) {
+     *   const res = await qstash.logs({ cursor })
+     *   logs.push(...res.logs)
+     *   cursor = res.cursor ?? 0
+     * }
+     * ```
+     */
+    logs(req?: LogsRequest): Promise<GetLogsRespone>;
+}
+declare type PublishResponse<PublishRequest> = PublishRequest extends {
+    cron: string;
+} ? {
+    scheduleId: string;
+} : {
+    messageId: string;
+};
+export {};

package/types/pkg/client/endpoints.d.ts

@@ -0,0 +1,59 @@
+import { Requester } from "./http.js";
+export declare type CreateEndpointRequest = {
+    /**
+     * The url of the endpoint.
+     */
+    url: string;
+    /**
+     * The name of the topic to subscribe to.
+     */
+    topicName: string;
+};
+export declare type GetEndpointRequest = {
+    id: string;
+};
+export declare type UpdateEndpointRequest = {
+    id: string;
+    url?: string;
+};
+export declare type DeleteEndpointRequest = {
+    id: string;
+};
+export declare type Endpoint = {
+    /**
+     * id for this endpoint
+     */
+    id: string;
+    /**
+     * The url of this endpoint.
+     */
+    url: string;
+    /**
+     * The topic id this endpoint is subscribed to.
+     */
+    topicId: string;
+};
+export declare class Endpoints {
+    private readonly http;
+    constructor(http: Requester);
+    /**
+     * Create a new endpoint with the given name.
+     */
+    create(req: CreateEndpointRequest): Promise<Endpoint>;
+    /**
+     * Get a list of all endpoints.
+     */
+    list(): Promise<Endpoint[]>;
+    /**
+     * Get a single endpoint.
+     */
+    get(req: GetEndpointRequest): Promise<Endpoint>;
+    /**
+     * Update a endpoint
+     */
+    update(req: UpdateEndpointRequest): Promise<Endpoint>;
+    /**
+     * Delete a endpoint.
+     */
+    delete(req: DeleteEndpointRequest): Promise<void>;
+}

package/types/pkg/client/error.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Result of 500 Internal Server Error
+ */
+export declare class QstashError extends Error {
+    constructor(message: string);
+}

package/types/pkg/client/http.d.ts

@@ -0,0 +1,66 @@
+import type { BodyInit, HeadersInit } from "../../deps/raw.githubusercontent.com/microsoft/TypeScript/main/lib/lib.dom";
+export declare type UpstashRequest = {
+    /**
+     * The path to the resource.
+     */
+    path: string[];
+    /**
+     * A BodyInit object or null to set request's body.
+     */
+    body?: BodyInit | null;
+    /**
+     * A Headers object, an object literal, or an array of two-item arrays to set
+     * request's headers.
+     */
+    headers?: HeadersInit;
+    /**
+     * A boolean to set request's keepalive.
+     */
+    keepalive?: boolean;
+    /**
+     * A string to set request's method.
+     */
+    method?: "GET" | "POST" | "PUT" | "DELETE";
+    query?: Record<string, string | number | boolean | undefined>;
+};
+export declare type UpstashResponse<TResult> = TResult & {
+    error?: string;
+};
+export interface Requester {
+    request: <TResult = unknown>(req: UpstashRequest) => Promise<UpstashResponse<TResult>>;
+}
+export declare type RetryConfig = false | {
+    /**
+     * The number of retries to attempt before giving up.
+     *
+     * @default 5
+     */
+    retries?: number;
+    /**
+     * A backoff function receives the current retry cound and returns a number in milliseconds to wait before retrying.
+     *
+     * @default
+     * ```ts
+     * Math.exp(retryCount) * 50
+     * ```
+     */
+    backoff?: (retryCount: number) => number;
+};
+export declare type HttpClientConfig = {
+    baseUrl: string;
+    authorization: string;
+    retry?: RetryConfig;
+};
+export declare class HttpClient implements Requester {
+    readonly baseUrl: string;
+    readonly authorization: string;
+    readonly options?: {
+        backend?: string;
+    };
+    readonly retry: {
+        attempts: number;
+        backoff: (retryCount: number) => number;
+    };
+    constructor(config: HttpClientConfig);
+    request<TResult>(req: UpstashRequest): Promise<UpstashResponse<TResult>>;
+}

package/types/pkg/client/messages.d.ts

@@ -0,0 +1,66 @@
+import { Requester } from "./http.js";
+import type { Log, Task } from "./types.js";
+export declare type GetMessageRequest = {
+    id: string;
+};
+export declare type CancelMessageRequest = {
+    id: string;
+};
+export declare type Message = {
+    messaged: string;
+    header: Record<string, string[]>;
+    body: string;
+} & ({
+    url: string;
+    topicd?: never;
+} | {
+    url?: never;
+    topicId: string;
+});
+export declare type ListMessagesRequest = {
+    cursor?: number;
+};
+export declare type ListMessagesResponse = {
+    cursor?: number;
+    messages: Message[];
+};
+export declare type ListLogsRequest = {
+    id: string;
+    cursor?: number;
+};
+export declare type ListLogsResponse = {
+    cursor?: number;
+    logs: Log[];
+};
+export declare type ListTasksRequest = {
+    id: string;
+    cursor?: number;
+};
+export declare type ListTasksResponse = {
+    cursor?: number;
+    logs: Task[];
+};
+export declare class Messages {
+    private readonly http;
+    constructor(http: Requester);
+    /**
+     * Get a message
+     */
+    get(req: GetMessageRequest): Promise<Message>;
+    /**
+     * List your messages
+     */
+    list(req?: ListMessagesRequest): Promise<ListMessagesResponse>;
+    /**
+     * List logs from a message
+     */
+    logs(req: ListLogsRequest): Promise<ListLogsResponse>;
+    /**
+     * List tasks for a message
+     */
+    tasks(req: ListTasksRequest): Promise<ListTasksResponse>;
+    /**
+     * Cancel a topic by name or id.
+     */
+    delete(req: CancelMessageRequest): Promise<void>;
+}