@upstash/qstash 2.7.5 → 2.7.6

package/{dist/workflow/index.d.mts → client-aUVEwn93.d.mts}

@@ -1,5 +1,66 @@
 import { Ok, Err } from 'neverthrow';
 
+/**
+ * Necessary to verify the signature of a request.
+ */
+type ReceiverConfig = {
+    /**
+     * The current signing key. Get it from `https://console.upstash.com/qstash
+     */
+    currentSigningKey: string;
+    /**
+     * The next signing key. Get it from `https://console.upstash.com/qstash
+     */
+    nextSigningKey: string;
+};
+type VerifyRequest = {
+    /**
+     * The signature from the `upstash-signature` header.
+     */
+    signature: string;
+    /**
+     * The raw request body.
+     */
+    body: string;
+    /**
+     * URL of the endpoint where the request was sent to.
+     *
+     * Omit empty to disable checking the url.
+     */
+    url?: string;
+    /**
+     * Number of seconds to tolerate when checking `nbf` and `exp` claims, to deal with small clock differences among different servers
+     *
+     * @default 0
+     */
+    clockTolerance?: number;
+};
+declare class SignatureError extends Error {
+    constructor(message: string);
+}
+/**
+ * Receiver offers a simple way to verify the signature of a request.
+ */
+declare class Receiver {
+    private readonly currentSigningKey;
+    private readonly nextSigningKey;
+    constructor(config: ReceiverConfig);
+    /**
+     * Verify the signature of a request.
+     *
+     * Tries to verify the signature with the current signing key.
+     * If that fails, maybe because you have rotated the keys recently, it will
+     * try to verify the signature with the next signing key.
+     *
+     * If that fails, the signature is invalid and a `SignatureError` is thrown.
+     */
+    verify(request: VerifyRequest): Promise<boolean>;
+    /**
+     * Verify signature with a specific signing key
+     */
+    private verifyWithKey;
+}
+
 type State = "CREATED" | "ACTIVE" | "DELIVERED" | "ERROR" | "RETRY" | "FAILED";
 type HTTPMethods = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
 type Event = {
@@ -15,14 +76,69 @@ type Event = {
     header?: Record<string, string>;
     body?: string;
 };
+type EventPayload = Omit<Event, "urlGroup"> & {
+    topicName: string;
+};
+type GetEventsPayload = {
+    cursor?: number;
+    events: EventPayload[];
+};
+type WithCursor<T> = T & {
+    cursor?: number;
+};
 type BodyInit = Blob | FormData | URLSearchParams | ReadableStream<Uint8Array> | string;
 type HeadersInit = Headers | Record<string, string> | [string, string][] | IterableIterator<[string, string]>;
+type RequestOptions = RequestInit & {
+    backend?: string;
+};
+type ChatRateLimit = {
+    "limit-requests": string | null;
+    "limit-tokens": string | null;
+    "remaining-requests": string | null;
+    "remaining-tokens": string | null;
+    "reset-requests": string | null;
+    "reset-tokens": string | null;
+};
+type RateLimit = {
+    limit: string | null;
+    remaining: string | null;
+    reset: string | null;
+};
 
 type ProviderReturnType = {
     owner: "upstash" | "openai" | "custom";
     baseUrl: string;
     token: string;
 };
+type AnalyticsConfig = {
+    name: "helicone";
+    token: string;
+};
+type AnalyticsSetup = {
+    baseURL?: string;
+    defaultHeaders?: Record<string, string | undefined>;
+};
+declare const setupAnalytics: (analytics: AnalyticsConfig | undefined, providerApiKey: string, providerBaseUrl?: string, provider?: "openai" | "upstash" | "custom") => AnalyticsSetup;
+declare const upstash: () => {
+    owner: "upstash";
+    baseUrl: "https://qstash.upstash.io/llm";
+    token: string;
+};
+declare const openai: ({ token, }: {
+    token: string;
+}) => {
+    owner: "openai";
+    baseUrl: "https://api.openai.com";
+    token: string;
+};
+declare const custom: ({ baseUrl, token, }: {
+    token: string;
+    baseUrl: string;
+}) => {
+    owner: "custom";
+    baseUrl: string;
+    token: string;
+};
 
 type ChatCompletionMessage = {
     role: "system" | "assistant" | "user";
@@ -191,64 +307,6 @@ type RetryConfig = false | {
     backoff?: (retryCount: number) => number;
 };
 
-/**
- * Necessary to verify the signature of a request.
- */
-type ReceiverConfig = {
-    /**
-     * The current signing key. Get it from `https://console.upstash.com/qstash
-     */
-    currentSigningKey: string;
-    /**
-     * The next signing key. Get it from `https://console.upstash.com/qstash
-     */
-    nextSigningKey: string;
-};
-type VerifyRequest = {
-    /**
-     * The signature from the `upstash-signature` header.
-     */
-    signature: string;
-    /**
-     * The raw request body.
-     */
-    body: string;
-    /**
-     * URL of the endpoint where the request was sent to.
-     *
-     * Omit empty to disable checking the url.
-     */
-    url?: string;
-    /**
-     * Number of seconds to tolerate when checking `nbf` and `exp` claims, to deal with small clock differences among different servers
-     *
-     * @default 0
-     */
-    clockTolerance?: number;
-};
-/**
- * Receiver offers a simple way to verify the signature of a request.
- */
-declare class Receiver {
-    private readonly currentSigningKey;
-    private readonly nextSigningKey;
-    constructor(config: ReceiverConfig);
-    /**
-     * Verify the signature of a request.
-     *
-     * Tries to verify the signature with the current signing key.
-     * If that fails, maybe because you have rotated the keys recently, it will
-     * try to verify the signature with the next signing key.
-     *
-     * If that fails, the signature is invalid and a `SignatureError` is thrown.
-     */
-    verify(request: VerifyRequest): Promise<boolean>;
-    /**
-     * Verify signature with a specific signing key
-     */
-    private verifyWithKey;
-}
-
 type Message = {
     /**
      * A unique identifier for this message.
@@ -325,6 +383,9 @@ type Message = {
      */
     callerIp?: string;
 };
+type MessagePayload = Omit<Message, "urlGroup"> & {
+    topicName: string;
+};
 declare class Messages {
     private readonly http;
     constructor(http: Requester);
@@ -754,965 +815,972 @@ declare class UrlGroups {
     delete(name: string): Promise<void>;
 }
 
-type ClientConfig = {
+/**
+ * Base class outlining steps. Basically, each step kind (run/sleep/sleepUntil)
+ * should have two methods: getPlanStep & getResultStep.
+ *
+ * getPlanStep works the same way for all so it's implemented here.
+ * The different step types will implement their own getResultStep method.
+ */
+declare abstract class BaseLazyStep<TResult = unknown> {
+    readonly stepName: string;
+    abstract readonly stepType: StepType;
+    constructor(stepName: string);
     /**
-     * Url of the QStash api server.
-     *
-     * This is only used for testing.
+     * plan step to submit when step will run parallel with other
+     * steps (parallel call state `first`)
      *
-     * @default "https://qstash.upstash.io"
-     */
-    baseUrl?: string;
-    /**
-     * The authorization token from the upstash console.
+     * @param concurrent number of steps running parallel
+     * @param targetStep target step id corresponding to this step
+     * @returns
      */
-    token: string;
+    abstract getPlanStep(concurrent: number, targetStep: number): Step<undefined>;
     /**
-     * Configure how the client should retry requests.
+     * result step to submit after the step executes. Used in single step executions
+     * and when a plan step executes in parallel executions (parallel call state `partial`).
+     *
+     * @param concurrent
+     * @param stepId
      */
-    retry?: RetryConfig;
+    abstract getResultStep(concurrent: number, stepId: number): Promise<Step<TResult>>;
+}
+
+declare const LOG_LEVELS: readonly ["DEBUG", "INFO", "SUBMIT", "WARN", "ERROR"];
+type LogLevel = (typeof LOG_LEVELS)[number];
+type ChatLogEntry = {
+    timestamp: number;
+    workflowRunId: string;
+    logLevel: LogLevel;
+    eventType: "ENDPOINT_START" | "SUBMIT_THIRD_PARTY_RESULT" | "CREATE_CONTEXT" | "SUBMIT_FIRST_INVOCATION" | "RUN_SINGLE" | "RUN_PARALLEL" | "SUBMIT_STEP" | "SUBMIT_CLEANUP" | "RESPONSE_WORKFLOW" | "RESPONSE_DEFAULT" | "ERROR";
+    details: unknown;
 };
-type PublishBatchRequest<TBody = BodyInit> = PublishRequest<TBody> & {
-    queueName?: string;
+type WorkflowLoggerOptions = {
+    logLevel: LogLevel;
+    logOutput: "console";
 };
-type PublishRequest<TBody = BodyInit> = {
+declare class WorkflowLogger {
+    private logs;
+    private options;
+    private workflowRunId?;
+    constructor(options: WorkflowLoggerOptions);
+    log(level: LogLevel, eventType: ChatLogEntry["eventType"], details?: unknown): Promise<void>;
+    setWorkflowRunId(workflowRunId: string): void;
+    private writeToConsole;
+    private shouldLog;
+    static getLogger(verbose?: boolean | WorkflowLogger): WorkflowLogger | undefined;
+}
+
+declare class AutoExecutor {
+    private context;
+    private promises;
+    private activeLazyStepList?;
+    private debug?;
+    private readonly nonPlanStepCount;
+    private readonly steps;
+    private indexInCurrentList;
+    stepCount: number;
+    planStepCount: number;
+    protected executingStep: string | false;
+    constructor(context: WorkflowContext, steps: Step[], debug?: WorkflowLogger);
     /**
-     * The message to send.
+     * Adds the step function to the list of step functions to run in
+     * parallel. After adding the function, defers the execution, so
+     * that if there is another step function to be added, it's also
+     * added.
      *
-     * This can be anything, but please set the `Content-Type` header accordingly.
+     * After all functions are added, list of functions are executed.
+     * If there is a single function, it's executed by itself. If there
+     * are multiple, they are run in parallel.
      *
-     * You can leave this empty if you want to send a message with no body.
-     */
-    body?: TBody;
-    /**
-     * Optionally send along headers with the message.
-     * These headers will be sent to your destination.
+     * If a function is already executing (this.executingStep), this
+     * means that there is a nested step which is not allowed. In this
+     * case, addStep throws QStashWorkflowError.
      *
-     * We highly recommend sending a `Content-Type` header along, as this will help your destination
-     * server to understand the content of the message.
+     * @param stepInfo step plan to add
+     * @returns result of the step function
      */
-    headers?: HeadersInit;
+    addStep<TResult>(stepInfo: BaseLazyStep<TResult>): Promise<TResult>;
     /**
-     * Optionally delay the delivery of this message.
+     * Wraps a step function to set this.executingStep to step name
+     * before running and set this.executingStep to False after execution
+     * ends.
      *
-     * In seconds.
+     * this.executingStep allows us to detect nested steps which are not
+     * allowed.
      *
-     * @default undefined
+     * @param stepName name of the step being wrapped
+     * @param stepFunction step function to wrap
+     * @returns wrapped step function
      */
-    delay?: Duration | number;
+    wrapStep<TResult = unknown>(stepName: string, stepFunction: StepFunction<TResult>): TResult | Promise<TResult>;
     /**
-     * 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.
+     * Executes a step:
+     * - If the step result is available in the steps, returns the result
+     * - If the result is not avaiable, runs the function
+     * - Sends the result to QStash
      *
-     * @default undefined
+     * @param lazyStep lazy step to execute
+     * @returns step result
      */
-    notBefore?: number;
+    protected runSingle<TResult>(lazyStep: BaseLazyStep<TResult>): Promise<TResult>;
     /**
-     * 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.
+     * Runs steps in parallel.
      *
-     * @default undefined
+     * @param stepName parallel step name
+     * @param stepFunctions list of async functions to run in parallel
+     * @returns results of the functions run in parallel
      */
-    deduplicationId?: string;
+    protected runParallel<TResults extends unknown[]>(parallelSteps: {
+        [K in keyof TResults]: BaseLazyStep<TResults[K]>;
+    }): Promise<TResults>;
     /**
-     * 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
+     * Determines the parallel call state
      *
-     * We store deduplication ids for 90 days. Afterwards it is possible that the message with the
-     * same deduplication id is delivered again.
+     * First filters the steps to get the steps which are after `initialStepCount` parameter.
      *
-     * When scheduling a message, the deduplication happens before the schedule is created.
+     * Depending on the remaining steps, decides the parallel state:
+     * - "first": If there are no steps
+     * - "last" If there are equal to or more than `2 * parallelStepCount`. We multiply by two
+     *   because each step in a parallel execution will have 2 steps: a plan step and a result
+     *   step.
+     * - "partial": If the last step is a plan step
+     * - "discard": If the last step is not a plan step. This means that the parallel execution
+     *   is in progress (there are still steps to run) and one step has finished and submitted
+     *   its result to QStash
      *
-     * @default false
+     * @param parallelStepCount number of steps to run in parallel
+     * @param initialStepCount steps after the parallel invocation
+     * @returns parallel call state
      */
-    contentBasedDeduplication?: boolean;
+    protected getParallelCallState(parallelStepCount: number, initialStepCount: number): ParallelCallState;
     /**
-     * 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 up to the maxRetries limit
-     * defined in your plan.
+     * sends the steps to QStash as batch
      *
-     * @default 3
+     * @param steps steps to send
      */
-    retries?: number;
+    private submitStepsToQStash;
     /**
-     * Use a failure callback url to handle messages that could not be delivered.
-     *
-     * The failure callback url must be publicly accessible
+     * Get the promise by executing the lazt steps list. If there is a single
+     * step, we call `runSingle`. Otherwise `runParallel` is called.
      *
-     * @default undefined
+     * @param lazyStepList steps list to execute
+     * @returns promise corresponding to the execution
      */
-    failureCallback?: string;
+    private getExecutionPromise;
     /**
-     * The method to use when sending a request to your API
-     *
-     * @default `POST`
+     * @param lazyStepList steps we executed
+     * @param result result of the promise from `getExecutionPromise`
+     * @param index index of the current step
+     * @returns result[index] if lazyStepList > 1, otherwise result
      */
-    method?: HTTPMethods;
+    private static getResult;
+    private deferExecution;
+}
+
+/**
+ * QStash workflow context
+ *
+ * See the docs for fields and methods https://upstash.com/docs/qstash/workflows/basics/context
+ */
+declare class WorkflowContext<TInitialPayload = unknown> {
+    protected readonly executor: AutoExecutor;
+    protected readonly steps: Step[];
     /**
-     * The HTTP timeout value to use while calling the destination URL.
-     * When a timeout is specified, it will be used instead of the maximum timeout
-     * value permitted by the QStash plan. It is useful in scenarios, where a message
-     * should be delivered with a shorter timeout.
+     * QStash client of the workflow
      *
-     * In seconds.
+     * Can be overwritten by passing `qstashClient` parameter in `serve`:
      *
-     * @default undefined
+     * ```ts
+     * import { Client } from "@upstash/qstash"
+     *
+     * export const POST = serve(
+     *   async (context) => {
+     *     ...
+     *   },
+     *   {
+     *     qstashClient: new Client({...})
+     *   }
+     * )
+     * ```
      */
-    timeout?: Duration | number;
-} & ({
+    readonly qstashClient: WorkflowClient;
     /**
-     * The url where the message should be sent to.
+     * Run id of the workflow
      */
-    url: string;
-    urlGroup?: never;
-    api?: never;
-    topic?: never;
+    readonly workflowRunId: string;
     /**
-     * Use a callback url to forward the response of your destination server to your callback url.
+     * URL of the workflow
      *
-     * The callback url must be publicly accessible
+     * Can be overwritten by passing a `url` parameter in `serve`:
      *
-     * @default undefined
-     */
-    callback?: string;
-} | {
-    url?: never;
-    /**
-     * The url group the message should be sent to.
+     * ```ts
+     * export const POST = serve(
+     *   async (context) => {
+     *     ...
+     *   },
+     *   {
+     *     url: "new-url-value"
+     *   }
+     * )
+     * ```
      */
-    urlGroup: string;
-    api?: never;
-    topic?: never;
+    readonly url: string;
     /**
-     * Use a callback url to forward the response of your destination server to your callback url.
+     * URL to call in case of workflow failure with QStash failure callback
      *
-     * The callback url must be publicly accessible
+     * https://upstash.com/docs/qstash/features/callbacks#what-is-a-failure-callback
      *
-     * @default undefined
-     */
-    callback?: string;
-} | {
-    url?: string;
-    urlGroup?: never;
-    /**
-     * The api endpoint the request should be sent to.
+     * Can be overwritten by passing a `failureUrl` parameter in `serve`:
+     *
+     * ```ts
+     * export const POST = serve(
+     *   async (context) => {
+     *     ...
+     *   },
+     *   {
+     *     failureUrl: "new-url-value"
+     *   }
+     * )
+     * ```
      */
-    api: {
-        name: "llm";
-        provider?: ProviderReturnType;
-        analytics?: {
-            name: "helicone";
-            token: string;
-        };
-    };
+    readonly failureUrl?: string;
     /**
-     * Use a callback url to forward the response of your destination server to your callback url.
+     * Payload of the request which started the workflow.
      *
-     * The callback url must be publicly accessible
+     * To specify its type, you can define `serve` as follows:
      *
-     * @default undefined
+     * ```ts
+     * // set requestPayload type to MyPayload:
+     * export const POST = serve<MyPayload>(
+     *   async (context) => {
+     *     ...
+     *   }
+     * )
+     * ```
+     *
+     * By default, `serve` tries to apply `JSON.parse` to the request payload.
+     * If your payload is encoded in a format other than JSON, you can utilize
+     * the `initialPayloadParser` parameter:
+     *
+     * ```ts
+     * export const POST = serve<MyPayload>(
+     *   async (context) => {
+     *     ...
+     *   },
+     *   {
+     *     initialPayloadParser: (initialPayload) => {return doSomething(initialPayload)}
+     *   }
+     * )
+     * ```
      */
-    callback: string;
-    topic?: never;
-} | {
-    url?: never;
-    urlGroup?: never;
-    api: never;
+    readonly requestPayload: TInitialPayload;
     /**
-     * Deprecated. The topic the message should be sent to. Same as urlGroup
+     * headers of the initial request
      */
-    topic?: string;
+    readonly headers: Headers;
     /**
-     * Use a callback url to forward the response of your destination server to your callback url.
+     * initial payload as a raw string
+     */
+    readonly rawInitialPayload: string;
+    /**
+     * Map of environment variables and their values.
      *
-     * The callback url must be publicly accessible
+     * Can be set using the `env` option of serve:
      *
-     * @default undefined
+     * ```ts
+     * export const POST = serve<MyPayload>(
+     *   async (context) => {
+     *     const key = context.env["API_KEY"];
+     *   },
+     *   {
+     *     env: {
+     *       "API_KEY": "*****";
+     *     }
+     *   }
+     * )
+     * ```
+     *
+     * Default value is set to `process.env`.
      */
-    callback?: string;
-});
-type EventsRequest = {
-    cursor?: number;
-    filter?: EventsRequestFilter;
-};
-type EventsRequestFilter = {
-    messageId?: string;
-    state?: State;
-    url?: string;
-    urlGroup?: string;
-    topicName?: string;
-    api?: string;
-    scheduleId?: string;
-    queueName?: string;
-    fromDate?: number;
-    toDate?: number;
-    count?: number;
-};
-type GetEventsResponse = {
-    cursor?: number;
-    events: Event[];
-};
-type QueueRequest = {
-    queueName?: string;
-};
-declare class Client {
-    http: Requester;
-    private token;
-    constructor(config: ClientConfig);
+    readonly env: Record<string, string | undefined>;
+    constructor({ qstashClient, workflowRunId, headers, steps, url, failureUrl, debug, initialPayload, rawInitialPayload, env, }: {
+        qstashClient: WorkflowClient;
+        workflowRunId: string;
+        headers: Headers;
+        steps: Step[];
+        url: string;
+        failureUrl?: string;
+        debug?: WorkflowLogger;
+        initialPayload: TInitialPayload;
+        rawInitialPayload?: string;
+        env?: Record<string, string | undefined>;
+    });
     /**
-     * Access the urlGroup API.
+     * Executes a workflow step
      *
-     * Create, read, update or delete urlGroups.
-     */
-    get urlGroups(): UrlGroups;
-    /**
-     * Deprecated. Use urlGroups instead.
+     * ```typescript
+     * const result = await context.run("step 1", () => {
+     *   return "result"
+     * })
+     * ```
      *
-     * Access the topic API.
+     * Can also be called in parallel and the steps will be executed
+     * simulatenously:
      *
-     * Create, read, update or delete topics.
+     * ```typescript
+     * const [result1, result2] = await Promise.all([
+     *   context.run("step 1", () => {
+     *     return "result1"
+     *   })
+     *   context.run("step 2", async () => {
+     *     return await fetchResults()
+     *   })
+     * ])
+     * ```
+     *
+     * @param stepName name of the step
+     * @param stepFunction step function to be executed
+     * @returns result of the step function
      */
-    get topics(): UrlGroups;
+    run<TResult>(stepName: string, stepFunction: StepFunction<TResult>): Promise<TResult>;
     /**
-     * Access the dlq API.
+     * Stops the execution for the duration provided.
      *
-     * List or remove messages from the DLQ.
+     * @param stepName
+     * @param duration sleep duration in seconds
+     * @returns undefined
      */
-    get dlq(): DLQ;
+    sleep(stepName: string, duration: number): Promise<void>;
     /**
-     * Access the message API.
+     * Stops the execution until the date time provided.
      *
-     * Read or cancel messages.
+     * @param stepName
+     * @param datetime time to sleep until. Can be provided as a number (in unix seconds),
+     *   as a Date object or a string (passed to `new Date(datetimeString)`)
+     * @returns undefined
      */
-    get messages(): Messages;
+    sleepUntil(stepName: string, datetime: Date | string | number): Promise<void>;
     /**
-     * Access the schedule API.
+     * Makes a third party call through QStash in order to make a
+     * network call without consuming any runtime.
      *
-     * Create, read or delete schedules.
+     * ```ts
+     * const postResult = await context.call<string>(
+     *   "post call step",
+     *   `https://www.some-endpoint.com/api`,
+     *   "POST",
+     *   "my-payload"
+     * );
+     * ```
+     *
+     * tries to parse the result of the request as JSON. If it's
+     * not a JSON which can be parsed, simply returns the response
+     * body as it is.
+     *
+     * @param stepName
+     * @param url url to call
+     * @param method call method
+     * @param body call body
+     * @param headers call headers
+     * @returns call result (parsed as JSON if possible)
      */
-    get schedules(): Schedules;
+    call<TResult = unknown, TBody = unknown>(stepName: string, url: string, method: HTTPMethods, body?: TBody, headers?: Record<string, string>): Promise<TResult>;
     /**
-     * Access the workflow API.
-     *
-     * cancel workflows.
+     * Adds steps to the executor. Needed so that it can be overwritten in
+     * DisabledWorkflowContext.
      */
-    get workflow(): Workflow;
+    protected addStep<TResult = unknown>(step: BaseLazyStep<TResult>): Promise<TResult>;
+}
+/**
+ * Workflow context which throws QStashWorkflowAbort before running the steps.
+ *
+ * Used for making a dry run before running any steps to check authentication.
+ *
+ * Consider an endpoint like this:
+ * ```ts
+ * export const POST = serve({
+ *   routeFunction: context => {
+ *     if (context.headers.get("authentication") !== "Bearer secretPassword") {
+ *       console.error("Authentication failed.");
+ *       return;
+ *     }
+ *
+ *     // ...
+ *   }
+ * })
+ * ```
+ *
+ * the serve method will first call the routeFunction with an DisabledWorkflowContext.
+ * Here is the action we take in different cases
+ * - "step-found": we will run the workflow related sections of `serve`.
+ * - "run-ended": simply return success and end the workflow
+ * - error: returns 500.
+ */
+declare class DisabledWorkflowContext<TInitialPayload = unknown> extends WorkflowContext<TInitialPayload> {
+    private static readonly disabledMessage;
     /**
-     * Access the queue API.
+     * overwrite the WorkflowContext.addStep method to always raise QStashWorkflowAbort
+     * error in order to stop the execution whenever we encounter a step.
      *
-     * Create, read, update or delete queues.
+     * @param _step
      */
-    queue(request?: QueueRequest): Queue;
+    protected addStep<TResult = unknown>(_step: BaseLazyStep<TResult>): Promise<TResult>;
     /**
-     * Access the Chat API
+     * copies the passed context to create a DisabledWorkflowContext. Then, runs the
+     * route function with the new context.
      *
-     * Call the create or prompt methods
+     * - returns "run-ended" if there are no steps found or
+     *      if the auth failed and user called `return`
+     * - returns "step-found" if DisabledWorkflowContext.addStep is called.
+     * - if there is another error, returns the error.
+     *
+     * @param routeFunction
      */
-    chat(): Chat;
-    publish<TRequest extends PublishRequest>(request: TRequest): Promise<PublishResponse<TRequest>>;
+    static tryAuthentication<TInitialPayload = unknown>(routeFunction: RouteFunction<TInitialPayload>, context: WorkflowContext<TInitialPayload>): Promise<Ok<"step-found" | "run-ended", never> | Err<never, Error>>;
+}
+
+/**
+ * Interface for Client with required methods
+ *
+ * Neeeded to resolve import issues
+ */
+type WorkflowClient = {
+    batchJSON: InstanceType<typeof Client>["batchJSON"];
+    publishJSON: InstanceType<typeof Client>["publishJSON"];
+    http: InstanceType<typeof Client>["http"];
+};
+/**
+ * Interface for Receiver with required methods
+ *
+ * Neeeded to resolve import issues
+ */
+type WorkflowReceiver = {
+    verify: InstanceType<typeof Receiver>["verify"];
+};
+declare const StepTypes: readonly ["Initial", "Run", "SleepFor", "SleepUntil", "Call"];
+type StepType = (typeof StepTypes)[number];
+type ThirdPartyCallFields<TBody = unknown> = {
     /**
-     * publishJSON is a utility wrapper around `publish` that automatically serializes the body
-     * and sets the `Content-Type` header to `application/json`.
+     * Third party call URL. Set when context.call is used.
      */
-    publishJSON<TBody = unknown, TRequest extends PublishRequest<TBody> = PublishRequest<TBody>>(request: TRequest): Promise<PublishResponse<TRequest>>;
+    callUrl: string;
     /**
-     * Batch publish messages to QStash.
+     * Third party call method. Set when context.call is used.
      */
-    batch(request: PublishBatchRequest[]): Promise<PublishResponse<PublishRequest>[]>;
+    callMethod: HTTPMethods;
     /**
-     * Batch publish messages to QStash, serializing each body to JSON.
+     * Third party call body. Set when context.call is used.
      */
-    batchJSON<TBody = unknown, TRequest extends PublishBatchRequest<TBody> = PublishBatchRequest<TBody>>(request: TRequest[]): Promise<PublishResponse<TRequest>[]>;
+    callBody: TBody;
     /**
-     * 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
-     * }
-     * ```
+     * Third party call headers. Set when context.call is used.
      */
-    events(request?: EventsRequest): Promise<GetEventsResponse>;
-}
-type PublishToApiResponse = {
-    messageId: string;
-};
-type PublishToUrlResponse = PublishToApiResponse & {
-    url: string;
-    deduplicated?: boolean;
+    callHeaders: Record<string, string>;
 };
-type PublishToUrlGroupsResponse = PublishToUrlResponse[];
-type PublishResponse<TRequest> = TRequest extends {
-    url: string;
-} ? PublishToUrlResponse : TRequest extends {
-    urlGroup: string;
-} ? PublishToUrlGroupsResponse : PublishToApiResponse;
-
-/**
- * Base class outlining steps. Basically, each step kind (run/sleep/sleepUntil)
- * should have two methods: getPlanStep & getResultStep.
- *
- * getPlanStep works the same way for all so it's implemented here.
- * The different step types will implement their own getResultStep method.
- */
-declare abstract class BaseLazyStep<TResult = unknown> {
-    readonly stepName: string;
-    abstract readonly stepType: StepType;
-    constructor(stepName: string);
+type Step<TResult = unknown, TBody = unknown> = {
     /**
-     * plan step to submit when step will run parallel with other
-     * steps (parallel call state `first`)
-     *
-     * @param concurrent number of steps running parallel
-     * @param targetStep target step id corresponding to this step
-     * @returns
+     * index of the step
      */
-    abstract getPlanStep(concurrent: number, targetStep: number): Step<undefined>;
+    stepId: number;
     /**
-     * result step to submit after the step executes. Used in single step executions
-     * and when a plan step executes in parallel executions (parallel call state `partial`).
-     *
-     * @param concurrent
-     * @param stepId
+     * name of the step
      */
-    abstract getResultStep(concurrent: number, stepId: number): Promise<Step<TResult>>;
-}
-
-declare const LOG_LEVELS: readonly ["DEBUG", "INFO", "SUBMIT", "WARN", "ERROR"];
-type LogLevel = (typeof LOG_LEVELS)[number];
-type ChatLogEntry = {
-    timestamp: number;
-    workflowRunId: string;
-    logLevel: LogLevel;
-    eventType: "ENDPOINT_START" | "SUBMIT_THIRD_PARTY_RESULT" | "CREATE_CONTEXT" | "SUBMIT_FIRST_INVOCATION" | "RUN_SINGLE" | "RUN_PARALLEL" | "SUBMIT_STEP" | "SUBMIT_CLEANUP" | "RESPONSE_WORKFLOW" | "RESPONSE_DEFAULT" | "ERROR";
-    details: unknown;
-};
-type WorkflowLoggerOptions = {
-    logLevel: LogLevel;
-    logOutput: "console";
-};
-declare class WorkflowLogger {
-    private logs;
-    private options;
-    private workflowRunId?;
-    constructor(options: WorkflowLoggerOptions);
-    log(level: LogLevel, eventType: ChatLogEntry["eventType"], details?: unknown): Promise<void>;
-    setWorkflowRunId(workflowRunId: string): void;
-    private writeToConsole;
-    private shouldLog;
-    static getLogger(verbose?: boolean | WorkflowLogger): WorkflowLogger | undefined;
-}
-
-declare class AutoExecutor {
-    private context;
-    private promises;
-    private activeLazyStepList?;
-    private debug?;
-    private readonly nonPlanStepCount;
-    private readonly steps;
-    private indexInCurrentList;
-    stepCount: number;
-    planStepCount: number;
-    protected executingStep: string | false;
-    constructor(context: WorkflowContext, steps: Step[], debug?: WorkflowLogger);
+    stepName: string;
     /**
-     * Adds the step function to the list of step functions to run in
-     * parallel. After adding the function, defers the execution, so
-     * that if there is another step function to be added, it's also
-     * added.
-     *
-     * After all functions are added, list of functions are executed.
-     * If there is a single function, it's executed by itself. If there
-     * are multiple, they are run in parallel.
-     *
-     * If a function is already executing (this.executingStep), this
-     * means that there is a nested step which is not allowed. In this
-     * case, addStep throws QStashWorkflowError.
-     *
-     * @param stepInfo step plan to add
-     * @returns result of the step function
+     * type of the step (Initial/Run/SleepFor/SleepUntil/Call)
      */
-    addStep<TResult>(stepInfo: BaseLazyStep<TResult>): Promise<TResult>;
+    stepType: StepType;
     /**
-     * Wraps a step function to set this.executingStep to step name
-     * before running and set this.executingStep to False after execution
-     * ends.
-     *
-     * this.executingStep allows us to detect nested steps which are not
-     * allowed.
-     *
-     * @param stepName name of the step being wrapped
-     * @param stepFunction step function to wrap
-     * @returns wrapped step function
+     * step result. Set if context.run or context.call are used.
      */
-    wrapStep<TResult = unknown>(stepName: string, stepFunction: StepFunction<TResult>): TResult | Promise<TResult>;
+    out?: TResult;
     /**
-     * Executes a step:
-     * - If the step result is available in the steps, returns the result
-     * - If the result is not avaiable, runs the function
-     * - Sends the result to QStash
-     *
-     * @param lazyStep lazy step to execute
-     * @returns step result
+     * sleep duration in seconds. Set when context.sleep is used.
      */
-    protected runSingle<TResult>(lazyStep: BaseLazyStep<TResult>): Promise<TResult>;
+    sleepFor?: number;
     /**
-     * Runs steps in parallel.
-     *
-     * @param stepName parallel step name
-     * @param stepFunctions list of async functions to run in parallel
-     * @returns results of the functions run in parallel
+     * unix timestamp (in seconds) to wait until. Set when context.sleepUntil is used.
      */
-    protected runParallel<TResults extends unknown[]>(parallelSteps: {
-        [K in keyof TResults]: BaseLazyStep<TResults[K]>;
-    }): Promise<TResults>;
+    sleepUntil?: number;
     /**
-     * Determines the parallel call state
-     *
-     * First filters the steps to get the steps which are after `initialStepCount` parameter.
-     *
-     * Depending on the remaining steps, decides the parallel state:
-     * - "first": If there are no steps
-     * - "last" If there are equal to or more than `2 * parallelStepCount`. We multiply by two
-     *   because each step in a parallel execution will have 2 steps: a plan step and a result
-     *   step.
-     * - "partial": If the last step is a plan step
-     * - "discard": If the last step is not a plan step. This means that the parallel execution
-     *   is in progress (there are still steps to run) and one step has finished and submitted
-     *   its result to QStash
-     *
-     * @param parallelStepCount number of steps to run in parallel
-     * @param initialStepCount steps after the parallel invocation
-     * @returns parallel call state
+     * number of steps running concurrently if the step is in a parallel run.
+     * Set to 1 if step is not parallel.
      */
-    protected getParallelCallState(parallelStepCount: number, initialStepCount: number): ParallelCallState;
+    concurrent: number;
     /**
-     * sends the steps to QStash as batch
+     * target step of a plan step. In other words, the step to assign the
+     * result of a plan step.
      *
-     * @param steps steps to send
+     * undefined if the step is not a plan step (of a parallel run). Otherwise,
+     * set to the target step.
      */
-    private submitStepsToQStash;
+    targetStep?: number;
+} & (ThirdPartyCallFields<TBody> | {
+    [P in keyof ThirdPartyCallFields]?: never;
+});
+type RawStep = {
+    messageId: string;
+    body: string;
+    callType: "step" | "toCallback" | "fromCallback";
+};
+type SyncStepFunction<TResult> = () => TResult;
+type AsyncStepFunction<TResult> = () => Promise<TResult>;
+type StepFunction<TResult> = AsyncStepFunction<TResult> | SyncStepFunction<TResult>;
+type ParallelCallState = "first" | "partial" | "discard" | "last";
+type RouteFunction<TInitialPayload> = (context: WorkflowContext<TInitialPayload>) => Promise<void>;
+type FinishCondition = "success" | "duplicate-step" | "fromCallback" | "auth-fail" | "failure-callback";
+type WorkflowServeOptions<TResponse extends Response = Response, TInitialPayload = unknown> = {
     /**
-     * Get the promise by executing the lazt steps list. If there is a single
-     * step, we call `runSingle`. Otherwise `runParallel` is called.
+     * QStash client
+     */
+    qstashClient?: WorkflowClient;
+    /**
+     * Function called to return a response after each step execution
      *
-     * @param lazyStepList steps list to execute
-     * @returns promise corresponding to the execution
+     * @param workflowRunId
+     * @returns response
      */
-    private getExecutionPromise;
+    onStepFinish?: (workflowRunId: string, finishCondition: FinishCondition) => TResponse;
     /**
-     * @param lazyStepList steps we executed
-     * @param result result of the promise from `getExecutionPromise`
-     * @param index index of the current step
-     * @returns result[index] if lazyStepList > 1, otherwise result
+     * Function to parse the initial payload passed by the user
      */
-    private static getResult;
-    private deferExecution;
-}
-
-/**
- * QStash workflow context
- *
- * See the docs for fields and methods https://upstash.com/docs/qstash/workflows/basics/context
- */
-declare class WorkflowContext<TInitialPayload = unknown> {
-    protected readonly executor: AutoExecutor;
-    protected readonly steps: Step[];
+    initialPayloadParser?: (initialPayload: string) => TInitialPayload;
     /**
-     * QStash client of the workflow
+     * Url of the endpoint where the workflow is set up.
      *
-     * Can be overwritten by passing `qstashClient` parameter in `serve`:
+     * If not set, url will be inferred from the request.
+     */
+    url?: string;
+    /**
+     * Verbose mode
      *
-     * ```ts
-     * import { Client } from "@upstash/qstash"
+     * Disabled if not set. If set to true, a logger is created automatically.
      *
-     * export const POST = serve(
-     *   async (context) => {
-     *     ...
-     *   },
-     *   {
-     *     qstashClient: new Client({...})
-     *   }
-     * )
-     * ```
+     * Alternatively, a WorkflowLogger can be passed.
      */
-    readonly qstashClient: WorkflowClient;
+    verbose?: WorkflowLogger | true;
     /**
-     * Run id of the workflow
+     * Receiver to verify *all* requests by checking if they come from QStash
+     *
+     * By default, a receiver is created from the env variables
+     * QSTASH_CURRENT_SIGNING_KEY and QSTASH_NEXT_SIGNING_KEY if they are set.
      */
-    readonly workflowRunId: string;
+    receiver?: WorkflowReceiver;
     /**
-     * URL of the workflow
-     *
-     * Can be overwritten by passing a `url` parameter in `serve`:
-     *
-     * ```ts
-     * export const POST = serve(
-     *   async (context) => {
-     *     ...
-     *   },
-     *   {
-     *     url: "new-url-value"
-     *   }
-     * )
-     * ```
+     * Url to call if QStash retries are exhausted while executing the workflow
      */
-    readonly url: string;
+    failureUrl?: string;
     /**
-     * URL to call in case of workflow failure with QStash failure callback
-     *
-     * https://upstash.com/docs/qstash/features/callbacks#what-is-a-failure-callback
-     *
-     * Can be overwritten by passing a `failureUrl` parameter in `serve`:
+     * Failure function called when QStash retries are exhausted while executing
+     * the workflow. Will overwrite `failureUrl` parameter with the workflow
+     * endpoint if passed.
      *
-     * ```ts
-     * export const POST = serve(
-     *   async (context) => {
-     *     ...
-     *   },
-     *   {
-     *     failureUrl: "new-url-value"
-     *   }
-     * )
-     * ```
+     * @param context workflow context at the moment of error
+     * @param failStatus error status
+     * @param failResponse error message
+     * @returns void
      */
-    readonly failureUrl?: string;
+    failureFunction?: (context: Omit<WorkflowContext, "run" | "sleepUntil" | "sleep" | "call">, failStatus: number, failResponse: string, failHeader: Record<string, string[]>) => Promise<void> | void;
     /**
-     * Payload of the request which started the workflow.
-     *
-     * To specify its type, you can define `serve` as follows:
+     * Base Url of the workflow endpoint
      *
-     * ```ts
-     * // set requestPayload type to MyPayload:
-     * export const POST = serve<MyPayload>(
-     *   async (context) => {
-     *     ...
-     *   }
-     * )
-     * ```
+     * Can be used to set if there is a local tunnel or a proxy between
+     * QStash and the workflow endpoint.
      *
-     * By default, `serve` tries to apply `JSON.parse` to the request payload.
-     * If your payload is encoded in a format other than JSON, you can utilize
-     * the `initialPayloadParser` parameter:
+     * Will be set to the env variable UPSTASH_WORKFLOW_URL if not passed.
+     * If the env variable is not set, the url will be infered as usual from
+     * the `request.url` or the `url` parameter in `serve` options.
      *
-     * ```ts
-     * export const POST = serve<MyPayload>(
-     *   async (context) => {
-     *     ...
-     *   },
-     *   {
-     *     initialPayloadParser: (initialPayload) => {return doSomething(initialPayload)}
-     *   }
-     * )
-     * ```
+     * @default undefined
      */
-    readonly requestPayload: TInitialPayload;
+    baseUrl?: string;
     /**
-     * headers of the initial request
+     * Optionally, one can pass an env object mapping environment
+     * variables to their keys.
+     *
+     * Useful in cases like cloudflare with hono.
      */
-    readonly headers: Headers;
+    env?: Record<string, string | undefined>;
+};
+/**
+ * Payload passed as body in failureFunction
+ */
+type FailureFunctionPayload = {
     /**
-     * initial payload as a raw string
+     * error name
      */
-    readonly rawInitialPayload: string;
+    error: string;
     /**
-     * Map of environment variables and their values.
-     *
-     * Can be set using the `env` option of serve:
-     *
-     * ```ts
-     * export const POST = serve<MyPayload>(
-     *   async (context) => {
-     *     const key = context.env["API_KEY"];
-     *   },
-     *   {
-     *     env: {
-     *       "API_KEY": "*****";
-     *     }
-     *   }
-     * )
-     * ```
-     *
-     * Default value is set to `process.env`.
+     * error message
      */
-    readonly env: Record<string, string | undefined>;
-    constructor({ qstashClient, workflowRunId, headers, steps, url, failureUrl, debug, initialPayload, rawInitialPayload, env, }: {
-        qstashClient: WorkflowClient;
-        workflowRunId: string;
-        headers: Headers;
-        steps: Step[];
-        url: string;
-        failureUrl?: string;
-        debug?: WorkflowLogger;
-        initialPayload: TInitialPayload;
-        rawInitialPayload?: string;
-        env?: Record<string, string | undefined>;
-    });
+    message: string;
+};
+/**
+ * Makes all fields except the ones selected required
+ */
+type RequiredExceptFields<T, K extends keyof T> = Omit<Required<T>, K> & Partial<Pick<T, K>>;
+
+/**
+ * Fills the options with default values if they are not provided.
+ *
+ * Default values for:
+ * - qstashClient: QStash client created with QSTASH_URL and QSTASH_TOKEN env vars
+ * - onStepFinish: returns a Response with workflowRunId & finish condition in the body (status: 200)
+ * - initialPayloadParser: calls JSON.parse if initial request body exists.
+ * - receiver: a Receiver if the required env vars are set
+ * - baseUrl: env variable UPSTASH_WORKFLOW_URL
+ *
+ * @param options options including the client, onFinish and initialPayloadParser
+ * @returns
+ */
+declare const processOptions: <TResponse extends Response = Response, TInitialPayload = unknown>(options?: WorkflowServeOptions<TResponse, TInitialPayload>) => RequiredExceptFields<WorkflowServeOptions<TResponse, TInitialPayload>, "verbose" | "receiver" | "url" | "failureFunction" | "failureUrl" | "baseUrl">;
+/**
+ * Creates an async method that handles incoming requests and runs the provided
+ * route function as a workflow.
+ *
+ * @param routeFunction - A function that uses WorkflowContext as a parameter and runs a workflow.
+ * @param options - Options including the client, onFinish callback, and initialPayloadParser.
+ * @returns An async method that consumes incoming requests and runs the workflow.
+ */
+declare const serve: <TInitialPayload = unknown, TRequest extends Request = Request, TResponse extends Response = Response>(routeFunction: RouteFunction<TInitialPayload>, options?: WorkflowServeOptions<TResponse, TInitialPayload>) => ((request: TRequest) => Promise<TResponse>);
+
+declare class Workflow {
+    private readonly http;
+    constructor(http: Requester);
     /**
-     * Executes a workflow step
-     *
-     * ```typescript
-     * const result = await context.run("step 1", () => {
-     *   return "result"
-     * })
-     * ```
+     * Cancel an ongoing workflow
      *
-     * Can also be called in parallel and the steps will be executed
-     * simulatenously:
+     * @param workflowRunId run id of the workflow to delete
+     * @returns true if workflow is succesfully deleted. Otherwise throws QStashError
+     */
+    cancel(workflowRunId: string): Promise<true | {
+        error: string;
+    }>;
+}
+
+type ClientConfig = {
+    /**
+     * Url of the QStash api server.
      *
-     * ```typescript
-     * const [result1, result2] = await Promise.all([
-     *   context.run("step 1", () => {
-     *     return "result1"
-     *   })
-     *   context.run("step 2", async () => {
-     *     return await fetchResults()
-     *   })
-     * ])
-     * ```
+     * This is only used for testing.
      *
-     * @param stepName name of the step
-     * @param stepFunction step function to be executed
-     * @returns result of the step function
+     * @default "https://qstash.upstash.io"
      */
-    run<TResult>(stepName: string, stepFunction: StepFunction<TResult>): Promise<TResult>;
+    baseUrl?: string;
     /**
-     * Stops the execution for the duration provided.
-     *
-     * @param stepName
-     * @param duration sleep duration in seconds
-     * @returns undefined
+     * The authorization token from the upstash console.
      */
-    sleep(stepName: string, duration: number): Promise<void>;
+    token: string;
     /**
-     * Stops the execution until the date time provided.
-     *
-     * @param stepName
-     * @param datetime time to sleep until. Can be provided as a number (in unix seconds),
-     *   as a Date object or a string (passed to `new Date(datetimeString)`)
-     * @returns undefined
+     * Configure how the client should retry requests.
      */
-    sleepUntil(stepName: string, datetime: Date | string | number): Promise<void>;
+    retry?: RetryConfig;
+};
+type PublishBatchRequest<TBody = BodyInit> = PublishRequest<TBody> & {
+    queueName?: string;
+};
+type PublishRequest<TBody = BodyInit> = {
     /**
-     * Makes a third party call through QStash in order to make a
-     * network call without consuming any runtime.
-     *
-     * ```ts
-     * const postResult = await context.call<string>(
-     *   "post call step",
-     *   `https://www.some-endpoint.com/api`,
-     *   "POST",
-     *   "my-payload"
-     * );
-     * ```
+     * The message to send.
      *
-     * tries to parse the result of the request as JSON. If it's
-     * not a JSON which can be parsed, simply returns the response
-     * body as it is.
+     * This can be anything, but please set the `Content-Type` header accordingly.
      *
-     * @param stepName
-     * @param url url to call
-     * @param method call method
-     * @param body call body
-     * @param headers call headers
-     * @returns call result (parsed as JSON if possible)
+     * You can leave this empty if you want to send a message with no body.
      */
-    call<TResult = unknown, TBody = unknown>(stepName: string, url: string, method: HTTPMethods, body?: TBody, headers?: Record<string, string>): Promise<TResult>;
+    body?: TBody;
     /**
-     * Adds steps to the executor. Needed so that it can be overwritten in
-     * DisabledWorkflowContext.
+     * 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.
      */
-    protected addStep<TResult = unknown>(step: BaseLazyStep<TResult>): Promise<TResult>;
-}
-/**
- * Workflow context which throws QStashWorkflowAbort before running the steps.
- *
- * Used for making a dry run before running any steps to check authentication.
- *
- * Consider an endpoint like this:
- * ```ts
- * export const POST = serve({
- *   routeFunction: context => {
- *     if (context.headers.get("authentication") !== "Bearer secretPassword") {
- *       console.error("Authentication failed.");
- *       return;
- *     }
- *
- *     // ...
- *   }
- * })
- * ```
- *
- * the serve method will first call the routeFunction with an DisabledWorkflowContext.
- * Here is the action we take in different cases
- * - "step-found": we will run the workflow related sections of `serve`.
- * - "run-ended": simply return success and end the workflow
- * - error: returns 500.
- */
-declare class DisabledWorkflowContext<TInitialPayload = unknown> extends WorkflowContext<TInitialPayload> {
-    private static readonly disabledMessage;
+    headers?: HeadersInit;
     /**
-     * overwrite the WorkflowContext.addStep method to always raise QStashWorkflowAbort
-     * error in order to stop the execution whenever we encounter a step.
+     * Optionally delay the delivery of this message.
      *
-     * @param _step
+     * In seconds.
+     *
+     * @default undefined
      */
-    protected addStep<TResult = unknown>(_step: BaseLazyStep<TResult>): Promise<TResult>;
+    delay?: Duration | number;
     /**
-     * copies the passed context to create a DisabledWorkflowContext. Then, runs the
-     * route function with the new context.
+     * Optionally set the absolute delay of this message.
+     * This will override the delay option.
+     * The message will not delivered until the specified time.
      *
-     * - returns "run-ended" if there are no steps found or
-     *      if the auth failed and user called `return`
-     * - returns "step-found" if DisabledWorkflowContext.addStep is called.
-     * - if there is another error, returns the error.
+     * Unix timestamp in seconds.
      *
-     * @param routeFunction
+     * @default undefined
      */
-    static tryAuthentication<TInitialPayload = unknown>(routeFunction: RouteFunction<TInitialPayload>, context: WorkflowContext<TInitialPayload>): Promise<Ok<"step-found" | "run-ended", never> | Err<never, Error>>;
-}
-
-/**
- * Interface for Client with required methods
- *
- * Neeeded to resolve import issues
- */
-type WorkflowClient = {
-    batchJSON: InstanceType<typeof Client>["batchJSON"];
-    publishJSON: InstanceType<typeof Client>["publishJSON"];
-    http: InstanceType<typeof Client>["http"];
-};
-/**
- * Interface for Receiver with required methods
- *
- * Neeeded to resolve import issues
- */
-type WorkflowReceiver = {
-    verify: InstanceType<typeof Receiver>["verify"];
-};
-declare const StepTypes: readonly ["Initial", "Run", "SleepFor", "SleepUntil", "Call"];
-type StepType = (typeof StepTypes)[number];
-type ThirdPartyCallFields<TBody = unknown> = {
+    notBefore?: number;
     /**
-     * Third party call URL. Set when context.call is used.
+     * 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
      */
-    callUrl: string;
+    deduplicationId?: string;
     /**
-     * Third party call method. Set when context.call is used.
+     * 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
      */
-    callMethod: HTTPMethods;
+    contentBasedDeduplication?: boolean;
     /**
-     * Third party call body. Set when context.call is used.
+     * 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 up to the maxRetries limit
+     * defined in your plan.
+     *
+     * @default 3
      */
-    callBody: TBody;
+    retries?: number;
     /**
-     * Third party call headers. Set when context.call is used.
+     * Use a failure callback url to handle messages that could not be delivered.
+     *
+     * The failure callback url must be publicly accessible
+     *
+     * @default undefined
      */
-    callHeaders: Record<string, string>;
-};
-type Step<TResult = unknown, TBody = unknown> = {
+    failureCallback?: string;
     /**
-     * index of the step
+     * The method to use when sending a request to your API
+     *
+     * @default `POST`
      */
-    stepId: number;
+    method?: HTTPMethods;
     /**
-     * name of the step
+     * The HTTP timeout value to use while calling the destination URL.
+     * When a timeout is specified, it will be used instead of the maximum timeout
+     * value permitted by the QStash plan. It is useful in scenarios, where a message
+     * should be delivered with a shorter timeout.
+     *
+     * In seconds.
+     *
+     * @default undefined
      */
-    stepName: string;
+    timeout?: Duration | number;
+} & ({
     /**
-     * type of the step (Initial/Run/SleepFor/SleepUntil/Call)
+     * The url where the message should be sent to.
      */
-    stepType: StepType;
+    url: string;
+    urlGroup?: never;
+    api?: never;
+    topic?: never;
     /**
-     * step result. Set if context.run or context.call are used.
+     * Use a callback url to forward the response of your destination server to your callback url.
+     *
+     * The callback url must be publicly accessible
+     *
+     * @default undefined
      */
-    out?: TResult;
+    callback?: string;
+} | {
+    url?: never;
     /**
-     * sleep duration in seconds. Set when context.sleep is used.
+     * The url group the message should be sent to.
      */
-    sleepFor?: number;
+    urlGroup: string;
+    api?: never;
+    topic?: never;
     /**
-     * unix timestamp (in seconds) to wait until. Set when context.sleepUntil is used.
+     * Use a callback url to forward the response of your destination server to your callback url.
+     *
+     * The callback url must be publicly accessible
+     *
+     * @default undefined
      */
-    sleepUntil?: number;
+    callback?: string;
+} | {
+    url?: string;
+    urlGroup?: never;
     /**
-     * number of steps running concurrently if the step is in a parallel run.
-     * Set to 1 if step is not parallel.
+     * The api endpoint the request should be sent to.
      */
-    concurrent: number;
+    api: {
+        name: "llm";
+        provider?: ProviderReturnType;
+        analytics?: {
+            name: "helicone";
+            token: string;
+        };
+    };
     /**
-     * target step of a plan step. In other words, the step to assign the
-     * result of a plan step.
+     * Use a callback url to forward the response of your destination server to your callback url.
      *
-     * undefined if the step is not a plan step (of a parallel run). Otherwise,
-     * set to the target step.
+     * The callback url must be publicly accessible
+     *
+     * @default undefined
      */
-    targetStep?: number;
-} & (ThirdPartyCallFields<TBody> | {
-    [P in keyof ThirdPartyCallFields]?: never;
-});
-type RawStep = {
-    messageId: string;
-    body: string;
-    callType: "step" | "toCallback" | "fromCallback";
-};
-type SyncStepFunction<TResult> = () => TResult;
-type AsyncStepFunction<TResult> = () => Promise<TResult>;
-type StepFunction<TResult> = AsyncStepFunction<TResult> | SyncStepFunction<TResult>;
-type ParallelCallState = "first" | "partial" | "discard" | "last";
-type RouteFunction<TInitialPayload> = (context: WorkflowContext<TInitialPayload>) => Promise<void>;
-type FinishCondition = "success" | "duplicate-step" | "fromCallback" | "auth-fail" | "failure-callback";
-type WorkflowServeOptions<TResponse extends Response = Response, TInitialPayload = unknown> = {
+    callback: string;
+    topic?: never;
+} | {
+    url?: never;
+    urlGroup?: never;
+    api: never;
     /**
-     * QStash client
+     * Deprecated. The topic the message should be sent to. Same as urlGroup
      */
-    qstashClient?: WorkflowClient;
+    topic?: string;
     /**
-     * Function called to return a response after each step execution
+     * Use a callback url to forward the response of your destination server to your callback url.
      *
-     * @param workflowRunId
-     * @returns response
+     * The callback url must be publicly accessible
+     *
+     * @default undefined
      */
-    onStepFinish?: (workflowRunId: string, finishCondition: FinishCondition) => TResponse;
+    callback?: string;
+});
+type PublishJsonRequest = Omit<PublishRequest, "body"> & {
     /**
-     * Function to parse the initial payload passed by the user
+     * The message to send.
+     * This can be anything as long as it can be serialized to JSON.
      */
-    initialPayloadParser?: (initialPayload: string) => TInitialPayload;
+    body: unknown;
+};
+type EventsRequest = {
+    cursor?: number;
+    filter?: EventsRequestFilter;
+};
+type EventsRequestFilter = {
+    messageId?: string;
+    state?: State;
+    url?: string;
+    urlGroup?: string;
+    topicName?: string;
+    api?: string;
+    scheduleId?: string;
+    queueName?: string;
+    fromDate?: number;
+    toDate?: number;
+    count?: number;
+};
+type GetEventsResponse = {
+    cursor?: number;
+    events: Event[];
+};
+type QueueRequest = {
+    queueName?: string;
+};
+declare class Client {
+    http: Requester;
+    private token;
+    constructor(config: ClientConfig);
     /**
-     * Url of the endpoint where the workflow is set up.
+     * Access the urlGroup API.
      *
-     * If not set, url will be inferred from the request.
+     * Create, read, update or delete urlGroups.
      */
-    url?: string;
+    get urlGroups(): UrlGroups;
     /**
-     * Verbose mode
+     * Deprecated. Use urlGroups instead.
      *
-     * Disabled if not set. If set to true, a logger is created automatically.
+     * Access the topic API.
      *
-     * Alternatively, a WorkflowLogger can be passed.
+     * Create, read, update or delete topics.
      */
-    verbose?: WorkflowLogger | true;
+    get topics(): UrlGroups;
     /**
-     * Receiver to verify *all* requests by checking if they come from QStash
+     * Access the dlq API.
      *
-     * By default, a receiver is created from the env variables
-     * QSTASH_CURRENT_SIGNING_KEY and QSTASH_NEXT_SIGNING_KEY if they are set.
+     * List or remove messages from the DLQ.
      */
-    receiver?: WorkflowReceiver;
+    get dlq(): DLQ;
     /**
-     * Url to call if QStash retries are exhausted while executing the workflow
+     * Access the message API.
+     *
+     * Read or cancel messages.
      */
-    failureUrl?: string;
+    get messages(): Messages;
     /**
-     * Failure function called when QStash retries are exhausted while executing
-     * the workflow. Will overwrite `failureUrl` parameter with the workflow
-     * endpoint if passed.
+     * Access the schedule API.
      *
-     * @param context workflow context at the moment of error
-     * @param failStatus error status
-     * @param failResponse error message
-     * @returns void
+     * Create, read or delete schedules.
      */
-    failureFunction?: (context: Omit<WorkflowContext, "run" | "sleepUntil" | "sleep" | "call">, failStatus: number, failResponse: string, failHeader: Record<string, string[]>) => Promise<void> | void;
+    get schedules(): Schedules;
     /**
-     * Base Url of the workflow endpoint
-     *
-     * Can be used to set if there is a local tunnel or a proxy between
-     * QStash and the workflow endpoint.
+     * Access the workflow API.
      *
-     * Will be set to the env variable UPSTASH_WORKFLOW_URL if not passed.
-     * If the env variable is not set, the url will be infered as usual from
-     * the `request.url` or the `url` parameter in `serve` options.
+     * cancel workflows.
+     */
+    get workflow(): Workflow;
+    /**
+     * Access the queue API.
      *
-     * @default undefined
+     * Create, read, update or delete queues.
      */
-    baseUrl?: string;
+    queue(request?: QueueRequest): Queue;
     /**
-     * Optionally, one can pass an env object mapping environment
-     * variables to their keys.
+     * Access the Chat API
      *
-     * Useful in cases like cloudflare with hono.
+     * Call the create or prompt methods
      */
-    env?: Record<string, string | undefined>;
-};
-/**
- * Payload passed as body in failureFunction
- */
-type FailureFunctionPayload = {
+    chat(): Chat;
+    publish<TRequest extends PublishRequest>(request: TRequest): Promise<PublishResponse<TRequest>>;
     /**
-     * error name
+     * publishJSON is a utility wrapper around `publish` that automatically serializes the body
+     * and sets the `Content-Type` header to `application/json`.
      */
-    error: string;
+    publishJSON<TBody = unknown, TRequest extends PublishRequest<TBody> = PublishRequest<TBody>>(request: TRequest): Promise<PublishResponse<TRequest>>;
     /**
-     * error message
+     * Batch publish messages to QStash.
      */
-    message: string;
-};
-/**
- * Makes all fields except the ones selected required
- */
-type RequiredExceptFields<T, K extends keyof T> = Omit<Required<T>, K> & Partial<Pick<T, K>>;
-
-/**
- * Fills the options with default values if they are not provided.
- *
- * Default values for:
- * - qstashClient: QStash client created with QSTASH_URL and QSTASH_TOKEN env vars
- * - onStepFinish: returns a Response with workflowRunId & finish condition in the body (status: 200)
- * - initialPayloadParser: calls JSON.parse if initial request body exists.
- * - receiver: a Receiver if the required env vars are set
- * - baseUrl: env variable UPSTASH_WORKFLOW_URL
- *
- * @param options options including the client, onFinish and initialPayloadParser
- * @returns
- */
-declare const processOptions: <TResponse extends Response = Response, TInitialPayload = unknown>(options?: WorkflowServeOptions<TResponse, TInitialPayload>) => RequiredExceptFields<WorkflowServeOptions<TResponse, TInitialPayload>, "verbose" | "receiver" | "url" | "failureFunction" | "failureUrl" | "baseUrl">;
-/**
- * Creates an async method that handles incoming requests and runs the provided
- * route function as a workflow.
- *
- * @param routeFunction - A function that uses WorkflowContext as a parameter and runs a workflow.
- * @param options - Options including the client, onFinish callback, and initialPayloadParser.
- * @returns An async method that consumes incoming requests and runs the workflow.
- */
-declare const serve: <TInitialPayload = unknown, TRequest extends Request = Request, TResponse extends Response = Response>(routeFunction: RouteFunction<TInitialPayload>, options?: WorkflowServeOptions<TResponse, TInitialPayload>) => ((request: TRequest) => Promise<TResponse>);
-
-declare class Workflow {
-    private readonly http;
-    constructor(http: Requester);
+    batch(request: PublishBatchRequest[]): Promise<PublishResponse<PublishRequest>[]>;
     /**
-     * Cancel an ongoing workflow
+     * Batch publish messages to QStash, serializing each body to JSON.
+     */
+    batchJSON<TBody = unknown, TRequest extends PublishBatchRequest<TBody> = PublishBatchRequest<TBody>>(request: TRequest[]): Promise<PublishResponse<TRequest>[]>;
+    /**
+     * Retrieve your logs.
      *
-     * @param workflowRunId run id of the workflow to delete
-     * @returns true if workflow is succesfully deleted. Otherwise throws QStashError
+     * 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
+     * }
+     * ```
      */
-    cancel(workflowRunId: string): Promise<true | {
-        error: string;
-    }>;
+    events(request?: EventsRequest): Promise<GetEventsResponse>;
 }
+type PublishToApiResponse = {
+    messageId: string;
+};
+type PublishToUrlResponse = PublishToApiResponse & {
+    url: string;
+    deduplicated?: boolean;
+};
+type PublishToUrlGroupsResponse = PublishToUrlResponse[];
+type PublishResponse<TRequest> = TRequest extends {
+    url: string;
+} ? PublishToUrlResponse : TRequest extends {
+    urlGroup: string;
+} ? PublishToUrlGroupsResponse : PublishToApiResponse;
 
-export { type AsyncStepFunction, DisabledWorkflowContext, type FailureFunctionPayload, type FinishCondition, type LogLevel, type ParallelCallState, type RawStep, type RequiredExceptFields, type RouteFunction, type Step, type StepFunction, type StepType, StepTypes, type SyncStepFunction, Workflow, type WorkflowClient, WorkflowContext, WorkflowLogger, type WorkflowLoggerOptions, type WorkflowReceiver, type WorkflowServeOptions, processOptions, serve };
+export { type AnalyticsConfig as $, type AddEndpointsRequest as A, type BodyInit as B, type ChatRateLimit as C, type ChatCompletion as D, type EventsRequest as E, type FailureFunctionPayload as F, type GetEventsResponse as G, type HTTPMethods as H, type ChatCompletionChunk as I, type StreamEnabled as J, type StreamDisabled as K, type StreamParameter as L, type Message as M, type PromptChatRequest as N, type OpenAIChatModel as O, type PublishBatchRequest as P, type QueueRequest as Q, type RateLimit as R, type Step as S, type ChatRequest as T, type UrlGroup as U, type VerifyRequest as V, type WithCursor as W, custom as X, openai as Y, upstash as Z, type ProviderReturnType as _, type ReceiverConfig as a, type AnalyticsSetup as a0, setupAnalytics as a1, type RouteFunction as a2, type WorkflowServeOptions as a3, Workflow as a4, processOptions as a5, serve as a6, WorkflowContext as a7, DisabledWorkflowContext as a8, type WorkflowClient as a9, type WorkflowReceiver as aa, StepTypes as ab, type StepType as ac, type RawStep as ad, type SyncStepFunction as ae, type AsyncStepFunction as af, type StepFunction as ag, type ParallelCallState as ah, type FinishCondition as ai, type RequiredExceptFields as aj, type LogLevel as ak, type WorkflowLoggerOptions as al, WorkflowLogger as am, SignatureError as b, Receiver as c, type PublishRequest as d, type PublishJsonRequest as e, Client as f, type PublishToApiResponse as g, type PublishToUrlResponse as h, type PublishToUrlGroupsResponse as i, type PublishResponse as j, type MessagePayload as k, Messages as l, type Schedule as m, type CreateScheduleRequest as n, Schedules as o, type Endpoint as p, type RemoveEndpointsRequest as q, UrlGroups as r, type State as s, type Event as t, type EventPayload as u, type GetEventsPayload as v, type HeadersInit as w, type RequestOptions as x, Chat as y, type ChatCompletionMessage as z };