@upstash/qstash 2.7.5 → 2.7.6-canary

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

@@ -1,5 +1,65 @@
-import { NextApiHandler } from 'next';
-import { NextRequest, NextFetchEvent, NextResponse } from 'next/server';
+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";
@@ -16,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";
@@ -192,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.
@@ -326,6 +383,9 @@ type Message = {
      */
     callerIp?: string;
 };
+type MessagePayload = Omit<Message, "urlGroup"> & {
+    topicName: string;
+};
 declare class Messages {
     private readonly http;
     constructor(http: Requester);
@@ -755,904 +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`).
+     * name of the step
+     */
+    stepName: string;
+    /**
+     * type of the step (Initial/Run/SleepFor/SleepUntil/Call)
+     */
+    stepType: StepType;
+    /**
+     * step result. Set if context.run or context.call are used.
+     */
+    out?: TResult;
+    /**
+     * sleep duration in seconds. Set when context.sleep is used.
+     */
+    sleepFor?: number;
+    /**
+     * unix timestamp (in seconds) to wait until. Set when context.sleepUntil is used.
+     */
+    sleepUntil?: number;
+    /**
+     * number of steps running concurrently if the step is in a parallel run.
+     * Set to 1 if step is not parallel.
+     */
+    concurrent: number;
+    /**
+     * target step of a plan step. In other words, the step to assign the
+     * result of a plan step.
      *
-     * @param concurrent
-     * @param stepId
+     * undefined if the step is not a plan step (of a parallel run). Otherwise,
+     * set to the target 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";
+    targetStep?: number;
+} & (ThirdPartyCallFields<TBody> | {
+    [P in keyof ThirdPartyCallFields]?: never;
+});
+type RawStep = {
+    messageId: string;
+    body: string;
+    callType: "step" | "toCallback" | "fromCallback";
 };
-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);
+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> = {
     /**
-     * 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
+     * QStash client
      */
-    addStep<TResult>(stepInfo: BaseLazyStep<TResult>): Promise<TResult>;
+    qstashClient?: WorkflowClient;
     /**
-     * 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.
+     * Function called to return a response after each step execution
      *
-     * @param stepName name of the step being wrapped
-     * @param stepFunction step function to wrap
-     * @returns wrapped step function
+     * @param workflowRunId
+     * @returns response
      */
-    wrapStep<TResult = unknown>(stepName: string, stepFunction: StepFunction<TResult>): TResult | Promise<TResult>;
+    onStepFinish?: (workflowRunId: string, finishCondition: FinishCondition) => TResponse;
     /**
-     * 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
+     * Function to parse the initial payload passed by the user
      */
-    protected runSingle<TResult>(lazyStep: BaseLazyStep<TResult>): Promise<TResult>;
+    initialPayloadParser?: (initialPayload: string) => TInitialPayload;
     /**
-     * Runs steps in parallel.
+     * Url of the endpoint where the workflow is set up.
      *
-     * @param stepName parallel step name
-     * @param stepFunctions list of async functions to run in parallel
-     * @returns results of the functions run in parallel
+     * If not set, url will be inferred from the request.
      */
-    protected runParallel<TResults extends unknown[]>(parallelSteps: {
-        [K in keyof TResults]: BaseLazyStep<TResults[K]>;
-    }): Promise<TResults>;
+    url?: string;
     /**
-     * Determines the parallel call state
-     *
-     * First filters the steps to get the steps which are after `initialStepCount` parameter.
+     * Verbose mode
      *
-     * 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
+     * Disabled if not set. If set to true, a logger is created automatically.
      *
-     * @param parallelStepCount number of steps to run in parallel
-     * @param initialStepCount steps after the parallel invocation
-     * @returns parallel call state
+     * Alternatively, a WorkflowLogger can be passed.
      */
-    protected getParallelCallState(parallelStepCount: number, initialStepCount: number): ParallelCallState;
+    verbose?: WorkflowLogger | true;
     /**
-     * sends the steps to QStash as batch
+     * Receiver to verify *all* requests by checking if they come from QStash
      *
-     * @param steps steps to send
+     * By default, a receiver is created from the env variables
+     * QSTASH_CURRENT_SIGNING_KEY and QSTASH_NEXT_SIGNING_KEY if they are set.
      */
-    private submitStepsToQStash;
+    receiver?: WorkflowReceiver;
     /**
-     * Get the promise by executing the lazt steps list. If there is a single
-     * step, we call `runSingle`. Otherwise `runParallel` is called.
-     *
-     * @param lazyStepList steps list to execute
-     * @returns promise corresponding to the execution
+     * Url to call if QStash retries are exhausted while executing the workflow
      */
-    private getExecutionPromise;
+    failureUrl?: string;
     /**
-     * @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
+     * Failure function called when QStash retries are exhausted while executing
+     * the workflow. Will overwrite `failureUrl` parameter with the workflow
+     * endpoint if passed.
+     *
+     * @param context workflow context at the moment of error
+     * @param failStatus error status
+     * @param failResponse error message
+     * @returns void
      */
-    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[];
+    failureFunction?: (context: Omit<WorkflowContext, "run" | "sleepUntil" | "sleep" | "call">, failStatus: number, failResponse: string, failHeader: Record<string, string[]>) => Promise<void> | void;
     /**
-     * QStash client of the workflow
+     * Base Url of the workflow endpoint
      *
-     * Can be overwritten by passing `qstashClient` parameter in `serve`:
+     * Can be used to set if there is a local tunnel or a proxy between
+     * QStash and the workflow endpoint.
      *
-     * ```ts
-     * import { Client } from "@upstash/qstash"
+     * 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.
      *
-     * export const POST = serve(
-     *   async (context) => {
-     *     ...
-     *   },
-     *   {
-     *     qstashClient: new Client({...})
-     *   }
-     * )
-     * ```
+     * @default undefined
      */
-    readonly qstashClient: WorkflowClient;
+    baseUrl?: string;
     /**
-     * Run id of the workflow
+     * Optionally, one can pass an env object mapping environment
+     * variables to their keys.
+     *
+     * Useful in cases like cloudflare with hono.
      */
-    readonly workflowRunId: string;
+    env?: Record<string, string | undefined>;
+};
+/**
+ * Payload passed as body in failureFunction
+ */
+type FailureFunctionPayload = {
     /**
-     * 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"
-     *   }
-     * )
-     * ```
+     * error name
      */
-    readonly url: string;
+    error: string;
+    /**
+     * error message
+     */
+    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);
     /**
-     * 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`:
+     * Cancel an ongoing workflow
      *
-     * ```ts
-     * export const POST = serve(
-     *   async (context) => {
-     *     ...
-     *   },
-     *   {
-     *     failureUrl: "new-url-value"
-     *   }
-     * )
-     * ```
+     * @param workflowRunId run id of the workflow to delete
+     * @returns true if workflow is succesfully deleted. Otherwise throws QStashError
      */
-    readonly failureUrl?: string;
+    cancel(workflowRunId: string): Promise<true | {
+        error: string;
+    }>;
+}
+
+type ClientConfig = {
     /**
-     * Payload of the request which started the workflow.
-     *
-     * To specify its type, you can define `serve` as follows:
-     *
-     * ```ts
-     * // set requestPayload type to MyPayload:
-     * export const POST = serve<MyPayload>(
-     *   async (context) => {
-     *     ...
-     *   }
-     * )
-     * ```
+     * Url of the QStash api server.
      *
-     * 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:
+     * This is only used for testing.
      *
-     * ```ts
-     * export const POST = serve<MyPayload>(
-     *   async (context) => {
-     *     ...
-     *   },
-     *   {
-     *     initialPayloadParser: (initialPayload) => {return doSomething(initialPayload)}
-     *   }
-     * )
-     * ```
+     * @default "https://qstash.upstash.io"
      */
-    readonly requestPayload: TInitialPayload;
+    baseUrl?: string;
     /**
-     * headers of the initial request
+     * The authorization token from the upstash console.
      */
-    readonly headers: Headers;
+    token: string;
     /**
-     * initial payload as a raw string
+     * Configure how the client should retry requests.
      */
-    readonly rawInitialPayload: string;
+    retry?: RetryConfig;
+};
+type PublishBatchRequest<TBody = BodyInit> = PublishRequest<TBody> & {
+    queueName?: string;
+};
+type PublishRequest<TBody = BodyInit> = {
     /**
-     * Map of environment variables and their values.
-     *
-     * Can be set using the `env` option of serve:
+     * The message to send.
      *
-     * ```ts
-     * export const POST = serve<MyPayload>(
-     *   async (context) => {
-     *     const key = context.env["API_KEY"];
-     *   },
-     *   {
-     *     env: {
-     *       "API_KEY": "*****";
-     *     }
-     *   }
-     * )
-     * ```
+     * This can be anything, but please set the `Content-Type` header accordingly.
      *
-     * Default value is set to `process.env`.
+     * You can leave this empty if you want to send a message with no body.
      */
-    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>;
-    });
+    body?: TBody;
     /**
-     * Executes a workflow step
-     *
-     * ```typescript
-     * const result = await context.run("step 1", () => {
-     *   return "result"
-     * })
-     * ```
-     *
-     * Can also be called in parallel and the steps will be executed
-     * simulatenously:
-     *
-     * ```typescript
-     * const [result1, result2] = await Promise.all([
-     *   context.run("step 1", () => {
-     *     return "result1"
-     *   })
-     *   context.run("step 2", async () => {
-     *     return await fetchResults()
-     *   })
-     * ])
-     * ```
+     * Optionally send along headers with the message.
+     * These headers will be sent to your destination.
      *
-     * @param stepName name of the step
-     * @param stepFunction step function to be executed
-     * @returns result of the step function
+     * We highly recommend sending a `Content-Type` header along, as this will help your destination
+     * server to understand the content of the message.
      */
-    run<TResult>(stepName: string, stepFunction: StepFunction<TResult>): Promise<TResult>;
+    headers?: HeadersInit;
     /**
-     * Stops the execution for the duration provided.
+     * Optionally delay the delivery of this message.
      *
-     * @param stepName
-     * @param duration sleep duration in seconds
-     * @returns undefined
+     * In seconds.
+     *
+     * @default undefined
      */
-    sleep(stepName: string, duration: number): Promise<void>;
+    delay?: Duration | number;
     /**
-     * Stops the execution until the date time provided.
+     * Optionally set the absolute delay of this message.
+     * This will override the delay option.
+     * The message will not delivered until the specified time.
      *
-     * @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
+     * Unix timestamp in seconds.
+     *
+     * @default undefined
      */
-    sleepUntil(stepName: string, datetime: Date | string | number): Promise<void>;
+    notBefore?: number;
     /**
-     * Makes a third party call through QStash in order to make a
-     * network call without consuming any runtime.
+     * 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.
      *
-     * ```ts
-     * const postResult = await context.call<string>(
-     *   "post call step",
-     *   `https://www.some-endpoint.com/api`,
-     *   "POST",
-     *   "my-payload"
-     * );
-     * ```
+     * We store deduplication ids for 90 days. Afterwards it is possible that the message with the
+     * same deduplication id is delivered again.
      *
-     * 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.
+     * When scheduling a message, the deduplication happens before the schedule is created.
      *
-     * @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)
+     * @default undefined
      */
-    call<TResult = unknown, TBody = unknown>(stepName: string, url: string, method: HTTPMethods, body?: TBody, headers?: Record<string, string>): Promise<TResult>;
+    deduplicationId?: string;
     /**
-     * Adds steps to the executor. Needed so that it can be overwritten in
-     * DisabledWorkflowContext.
+     * 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
      */
-    protected addStep<TResult = unknown>(step: BaseLazyStep<TResult>): Promise<TResult>;
-}
-
-/**
- * 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> = {
+    contentBasedDeduplication?: boolean;
     /**
-     * Third party call URL. 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
      */
-    callUrl: string;
+    retries?: number;
     /**
-     * Third party call method. 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
      */
-    callMethod: HTTPMethods;
+    failureCallback?: string;
     /**
-     * Third party call body. Set when context.call is used.
+     * The method to use when sending a request to your API
+     *
+     * @default `POST`
      */
-    callBody: TBody;
+    method?: HTTPMethods;
     /**
-     * Third party call headers. Set when context.call is used.
+     * 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
      */
-    callHeaders: Record<string, string>;
-};
-type Step<TResult = unknown, TBody = unknown> = {
+    timeout?: Duration | number;
+} & ({
     /**
-     * index of the step
+     * The url where the message should be sent to.
      */
-    stepId: number;
+    url: string;
+    urlGroup?: never;
+    api?: never;
+    topic?: never;
     /**
-     * name of the step
+     * 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
      */
-    stepName: string;
+    callback?: string;
+} | {
+    url?: never;
     /**
-     * type of the step (Initial/Run/SleepFor/SleepUntil/Call)
+     * The url group the message should be sent to.
      */
-    stepType: StepType;
+    urlGroup: string;
+    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?: string;
+    urlGroup?: never;
     /**
-     * sleep duration in seconds. Set when context.sleep is used.
+     * The api endpoint the request should be sent to.
      */
-    sleepFor?: number;
+    api: {
+        name: "llm";
+        provider?: ProviderReturnType;
+        analytics?: {
+            name: "helicone";
+            token: string;
+        };
+    };
     /**
-     * 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;
+    topic?: never;
+} | {
+    url?: never;
+    urlGroup?: never;
+    api: never;
     /**
-     * number of steps running concurrently if the step is in a parallel run.
-     * Set to 1 if step is not parallel.
+     * Deprecated. The topic the message should be sent to. Same as urlGroup
      */
-    concurrent: number;
+    topic?: 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;
+    callback?: string;
 });
-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> = {
+type PublishJsonRequest = Omit<PublishRequest, "body"> & {
     /**
-     * QStash client
+     * The message to send.
+     * This can be anything as long as it can be serialized to JSON.
      */
-    qstashClient?: WorkflowClient;
+    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);
     /**
-     * Function called to return a response after each step execution
+     * Access the urlGroup API.
      *
-     * @param workflowRunId
-     * @returns response
+     * Create, read, update or delete urlGroups.
      */
-    onStepFinish?: (workflowRunId: string, finishCondition: FinishCondition) => TResponse;
+    get urlGroups(): UrlGroups;
     /**
-     * Function to parse the initial payload passed by the user
+     * Deprecated. Use urlGroups instead.
+     *
+     * Access the topic API.
+     *
+     * Create, read, update or delete topics.
      */
-    initialPayloadParser?: (initialPayload: string) => TInitialPayload;
+    get topics(): UrlGroups;
     /**
-     * Url of the endpoint where the workflow is set up.
+     * Access the dlq API.
      *
-     * If not set, url will be inferred from the request.
+     * List or remove messages from the DLQ.
      */
-    url?: string;
+    get dlq(): DLQ;
     /**
-     * Verbose mode
-     *
-     * Disabled if not set. If set to true, a logger is created automatically.
+     * Access the message API.
      *
-     * Alternatively, a WorkflowLogger can be passed.
+     * Read or cancel messages.
      */
-    verbose?: WorkflowLogger | true;
+    get messages(): Messages;
     /**
-     * Receiver to verify *all* requests by checking if they come from QStash
+     * Access the schedule API.
      *
-     * By default, a receiver is created from the env variables
-     * QSTASH_CURRENT_SIGNING_KEY and QSTASH_NEXT_SIGNING_KEY if they are set.
+     * Create, read or delete schedules.
      */
-    receiver?: WorkflowReceiver;
+    get schedules(): Schedules;
     /**
-     * Url to call if QStash retries are exhausted while executing the workflow
+     * Access the workflow API.
+     *
+     * cancel workflows.
      */
-    failureUrl?: string;
+    get workflow(): Workflow;
     /**
-     * Failure function called when QStash retries are exhausted while executing
-     * the workflow. Will overwrite `failureUrl` parameter with the workflow
-     * endpoint if passed.
+     * Access the queue API.
      *
-     * @param context workflow context at the moment of error
-     * @param failStatus error status
-     * @param failResponse error message
-     * @returns void
+     * Create, read, update or delete queues.
      */
-    failureFunction?: (context: Omit<WorkflowContext, "run" | "sleepUntil" | "sleep" | "call">, failStatus: number, failResponse: string, failHeader: Record<string, string[]>) => Promise<void> | void;
+    queue(request?: QueueRequest): Queue;
     /**
-     * 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.
-     *
-     * 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.
+     * Access the Chat API
      *
-     * @default undefined
+     * Call the create or prompt methods
      */
-    baseUrl?: string;
+    chat(): Chat;
+    publish<TRequest extends PublishRequest>(request: TRequest): Promise<PublishResponse<TRequest>>;
     /**
-     * Optionally, one can pass an env object mapping environment
-     * variables to their keys.
-     *
-     * Useful in cases like cloudflare with hono.
+     * publishJSON is a utility wrapper around `publish` that automatically serializes the body
+     * and sets the `Content-Type` header to `application/json`.
      */
-    env?: Record<string, string | undefined>;
-};
-
-declare class Workflow {
-    private readonly http;
-    constructor(http: Requester);
+    publishJSON<TBody = unknown, TRequest extends PublishRequest<TBody> = PublishRequest<TBody>>(request: TRequest): Promise<PublishResponse<TRequest>>;
     /**
-     * Cancel an ongoing workflow
-     *
-     * @param workflowRunId run id of the workflow to delete
-     * @returns true if workflow is succesfully deleted. Otherwise throws QStashError
+     * Batch publish messages to QStash.
      */
-    cancel(workflowRunId: string): Promise<true | {
-        error: string;
-    }>;
-}
-
-type VerifySignatureConfig = {
-    currentSigningKey?: string;
-    nextSigningKey?: string;
+    batch(request: PublishBatchRequest[]): Promise<PublishResponse<PublishRequest>[]>;
     /**
-     * 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`
+     * Batch publish messages to QStash, serializing each body to JSON.
      */
-    url?: string;
+    batchJSON<TBody = unknown, TRequest extends PublishBatchRequest<TBody> = PublishBatchRequest<TBody>>(request: TRequest[]): Promise<PublishResponse<TRequest>[]>;
     /**
-     * Number of seconds to tolerate when checking `nbf` and `exp` claims, to deal with small clock differences among different servers
+     * Retrieve your logs.
      *
-     * @default 0
+     * 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
+     * }
+     * ```
      */
-    clockTolerance?: number;
+    events(request?: EventsRequest): Promise<GetEventsResponse>;
+}
+type PublishToApiResponse = {
+    messageId: string;
 };
-declare function verifySignature(handler: NextApiHandler, config?: VerifySignatureConfig): NextApiHandler;
-declare function verifySignatureEdge(handler: (request: NextRequest, nfe?: NextFetchEvent) => NextResponse | Promise<NextResponse>, config?: VerifySignatureConfig): (request: NextRequest, nfe: NextFetchEvent) => Promise<NextResponse<unknown>>;
-type VerifySignatureAppRouterResponse = NextResponse | Promise<NextResponse> | Response | Promise<Response>;
-declare function verifySignatureAppRouter(handler: ((request: Request, params?: unknown) => VerifySignatureAppRouterResponse) | ((request: NextRequest, params?: unknown) => VerifySignatureAppRouterResponse), config?: VerifySignatureConfig): (request: NextRequest | Request, params?: unknown) => Promise<Response>;
-/**
- * Serve method to serve a QStash workflow in a Nextjs project
- *
- * See for options https://upstash.com/docs/qstash/workflows/basics/serve
- *
- * @param routeFunction workflow function
- * @param options workflow options
- * @returns
- */
-declare const serve: <TInitialPayload = unknown>(routeFunction: RouteFunction<TInitialPayload>, options?: Omit<WorkflowServeOptions<NextResponse, TInitialPayload>, "onStepFinish">) => ((request: Request) => Promise<NextResponse>);
-declare const servePagesRouter: <TInitialPayload = unknown>(routeFunction: RouteFunction<TInitialPayload>, options?: Omit<WorkflowServeOptions<Response, TInitialPayload>, "onStepFinish">) => NextApiHandler;
+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 VerifySignatureConfig, serve, servePagesRouter, verifySignature, verifySignatureAppRouter, verifySignatureEdge };
+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 };