@cloudflare/workers-types 5.20260804.1 → 5.20260808.1

package/experimental/index.d.ts

@@ -503,6 +503,7 @@ interface ExecutionContext<Props = unknown> {
     readonly override?: string;
   };
   readonly access?: CloudflareAccessContext;
+  mapVirtualHost(fetcher: Fetcher, port: number): string;
   tracing: Tracing;
   abort(reason?: any): void;
 }
@@ -3414,6 +3415,12 @@ interface TraceLog {
   readonly timestamp: number;
   readonly level: string;
   readonly message: any;
+  readonly errorInfo?: (TraceLogErrorInfo | null)[];
+}
+interface TraceLogErrorInfo {
+  name: string;
+  message: string;
+  stack?: string;
 }
 interface TraceException {
   readonly timestamp: number;
@@ -3981,18 +3988,26 @@ interface ContainerExecOptions {
   cwd?: string;
   env?: Record<string, string>;
   user?: string;
+  signal?: AbortSignal;
+  pty?: boolean | ContainerExecPtyOptions;
   stdin?: ReadableStream | "pipe";
   stdout?: "pipe" | "ignore";
   stderr?: "pipe" | "ignore" | "combined";
 }
+interface ContainerExecPtyOptions {
+  cols?: number;
+  rows?: number;
+}
 interface ExecProcess {
   readonly stdin: WritableStream | null;
   readonly stdout: ReadableStream | null;
   readonly stderr: ReadableStream | null;
   readonly pid: number;
+  readonly isPty: boolean;
   readonly exitCode: Promise<number>;
   output(): Promise<ExecOutput>;
   kill(signal?: number): void;
+  resize(cols: number, rows: number): void;
 }
 interface Container {
   get running(): boolean;
@@ -4014,6 +4029,7 @@ interface Container {
   exec(cmd: string[], options?: ContainerExecOptions): Promise<ExecProcess>;
   interceptOutboundTcp(addr: string, binding: Fetcher): Promise<void>;
   inspect(): Promise<ContainerInfo | null>;
+  setLabels(labels: Record<string, string>): Promise<void>;
 }
 interface ContainerDirectorySnapshot {
   id: string;
@@ -4037,19 +4053,39 @@ interface ContainerSnapshot {
 interface ContainerSnapshotOptions {
   name?: string;
 }
-interface ContainerStartupOptions {
+type ContainerStartupOptions = {
   entrypoint?: string[];
   enableInternet: boolean;
   env?: Record<string, string>;
   hardTimeout?: number | bigint;
+  instance?:
+    | "lite"
+    | "standard-1"
+    | "standard-2"
+    | "standard-3"
+    | "standard-4"
+    | ContainerStartResources;
   labels?: Record<string, string>;
   directorySnapshots?: ContainerDirectorySnapshotRestoreParams[];
-  containerSnapshot?: ContainerSnapshot;
-}
+} & (
+  | {
+      image: string;
+      containerSnapshot?: never;
+    }
+  | {
+      image?: never;
+      containerSnapshot?: ContainerSnapshot;
+    }
+);
 interface ContainerInfo {
   labels: Record<string, string>;
   image: string;
 }
+interface ContainerStartResources {
+  vcpu: number;
+  memoryMib: number;
+  diskMb: number;
+}
 /**
  * The **`FileSystemHandle`** interface of the File System API is an object which represents a file or directory entry.
  * Available only in secure contexts.
@@ -4744,11 +4780,15 @@ interface Tracing {
     callback: (span: Span, ...args: A) => T,
     ...args: A
   ): T;
+  startSpan(name: string): Span;
   Span: typeof Span;
 }
 declare abstract class Span {
   get isTraced(): boolean;
-  setAttribute(key: string, value?: boolean | number | string): void;
+  setAttribute(key: string, value: boolean | number | string): this;
+  setAttributes(
+    attributes: Record<string, boolean | number | string | undefined>,
+  ): this;
   end(): void;
 }
 /**
@@ -5424,6 +5464,13 @@ type AiSearchListItemsParams = {
   source?: string;
   /** JSON-encoded Vectorize filter for metadata filtering. */
   metadata_filter?: string;
+  /** Filter items by their unique ID. Returns at most one item. */
+  item_id?: string;
+  /**
+   * Filter items by their exact key (object key / filename). Keys are unique
+   * per source, so combine with `source` to disambiguate across data sources.
+   */
+  key?: string;
 };
 type AiSearchListItemsResponse = {
   result: AiSearchItemInfo[];
@@ -14572,6 +14619,15 @@ interface Hyperdrive {
    * for your database.
    */
   readonly host: string;
+  /*
+   * A synthetic IPv4 address (in the reserved 240.0.0.0/4 range) that, like the
+   * host field, is only valid within the context of the currently running
+   * Worker and, when passed into the `connect()` function from the
+   * "cloudflare:sockets" module, will connect to the Hyperdrive instance for
+   * your database. This is provided for database drivers that require the host
+   * to be an IP literal rather than a hostname.
+   */
+  readonly ip: string;
   /*
    * The port that must be paired the the host field when connecting.
    */
@@ -15410,6 +15466,32 @@ declare namespace CloudflareWorkersModule {
     timeout?: WorkflowTimeoutDuration | number;
     sensitive?: WorkflowStepSensitivity;
   };
+  // Internal discriminators used only for `WorkflowStep.do` overload
+  // resolution. They mirror `WorkflowStepConfig` but pin `retries.delay` to a
+  // single kind so the callback context can be narrowed based on the shape of
+  // the config argument (rather than on an inferred type parameter, which is
+  // lost when the caller supplies an explicit return-type argument). Not
+  // exported: they must not widen the public type surface.
+  type WorkflowStepConfigWithStaticDelay = Omit<
+    WorkflowStepConfig,
+    "retries"
+  > & {
+    retries?: {
+      limit: number;
+      delay: WorkflowDelayDuration | number;
+      backoff?: WorkflowBackoff;
+    };
+  };
+  type WorkflowStepConfigWithDelayFunction = Omit<
+    WorkflowStepConfig,
+    "retries"
+  > & {
+    retries: {
+      limit: number;
+      delay: WorkflowDelayFunction;
+      backoff?: WorkflowBackoff;
+    };
+  };
   export type WorkflowStepRollbackConfig = Pick<
     WorkflowStepConfig,
     "retries" | "timeout"
@@ -15452,18 +15534,30 @@ declare namespace CloudflareWorkersModule {
       sensitive?: WorkflowStepSensitivity;
     };
   };
-  export type WorkflowRollbackContext<T = unknown> = {
-    ctx: WorkflowStepContext;
+  // The rollback handler receives the step context, so it mirrors the same
+  // delay discriminant as the step callback: when the step was configured with
+  // a dynamic delay function the resolved `config.retries.delay` is omitted,
+  // otherwise it is present. `Delay` is threaded from the `WorkflowStep.do`
+  // overload that matched the step config.
+  export type WorkflowRollbackContext<
+    T = unknown,
+    Delay = WorkflowDelayDuration | number,
+  > = {
+    ctx: WorkflowStepContext<Delay>;
     error: Error;
     output: T | undefined;
     /** @deprecated Use `ctx.step.name` and `ctx.step.count` instead. */
     stepName: string;
   };
-  export type WorkflowRollbackHandler<T = unknown> = (
-    ctx: WorkflowRollbackContext<T>,
-  ) => Promise<void>;
-  export type WorkflowStepRollbackOptions<T = unknown> = {
-    rollback: WorkflowRollbackHandler<T>;
+  export type WorkflowRollbackHandler<
+    T = unknown,
+    Delay = WorkflowDelayDuration | number,
+  > = (ctx: WorkflowRollbackContext<T, Delay>) => Promise<void>;
+  export type WorkflowStepRollbackOptions<
+    T = unknown,
+    Delay = WorkflowDelayDuration | number,
+  > = {
+    rollback: WorkflowRollbackHandler<T, Delay>;
     rollbackConfig?: WorkflowStepRollbackConfig;
   };
   export abstract class WorkflowStep {
@@ -15472,18 +15566,34 @@ declare namespace CloudflareWorkersModule {
       callback: (ctx: WorkflowStepContext) => Promise<T>,
       rollbackOptions?: WorkflowStepRollbackOptions<T>,
     ): Promise<T>;
-    do<T extends Rpc.Serializable<T>, const C extends WorkflowStepConfig>(
+    // The config overloads discriminate on the shape of `config.retries.delay`
+    // so the callback context reflects whether the resolved delay is present
+    // (static delay) or omitted (dynamic delay function). Each has a single
+    // type parameter, so an explicit return-type argument (`do<T>(...)`) still
+    // resolves here. ORDERING IS LOAD-BEARING: the broad `WorkflowStepConfig`
+    // fallback MUST remain last, otherwise it shadows the discriminating
+    // overloads and narrowing is silently lost.
+    do<T extends Rpc.Serializable<T>>(
       name: string,
-      config: C,
+      config: WorkflowStepConfigWithDelayFunction,
+      callback: (ctx: WorkflowStepContext<WorkflowDelayFunction>) => Promise<T>,
+      rollbackOptions?: WorkflowStepRollbackOptions<T, WorkflowDelayFunction>,
+    ): Promise<T>;
+    do<T extends Rpc.Serializable<T>>(
+      name: string,
+      config: WorkflowStepConfigWithStaticDelay,
       callback: (
-        ctx: WorkflowStepContext<
-          C["retries"] extends {
-            delay: infer D;
-          }
-            ? D
-            : WorkflowDelayDuration | number
-        >,
+        ctx: WorkflowStepContext<WorkflowDelayDuration | number>,
       ) => Promise<T>,
+      rollbackOptions?: WorkflowStepRollbackOptions<
+        T,
+        WorkflowDelayDuration | number
+      >,
+    ): Promise<T>;
+    do<T extends Rpc.Serializable<T>>(
+      name: string,
+      config: WorkflowStepConfig,
+      callback: (ctx: WorkflowStepContext) => Promise<T>,
       rollbackOptions?: WorkflowStepRollbackOptions<T>,
     ): Promise<T>;
     sleep: (name: string, duration: WorkflowSleepDuration) => Promise<void>;
@@ -16302,12 +16412,13 @@ type MarkdownDocument = {
   name: string;
   blob: Blob;
 };
+type OutputFormat = "markdown" | "text";
 type ConversionResponse =
   | {
       id: string;
       name: string;
       mimeType: string;
-      format: "markdown";
+      format: OutputFormat;
       tokens: number;
       data: string;
     }
@@ -16325,7 +16436,11 @@ type EmbeddedImageConversionOptions = ImageConversionOptions & {
   convert?: boolean;
   maxConvertedImages?: number;
 };
+type ConversionOutputOptions = {
+  format?: OutputFormat;
+};
 type ConversionOptions = {
+  output?: ConversionOutputOptions;
   html?: {
     images?: EmbeddedImageConversionOptions & {
       convertOGImage?: boolean;
@@ -16506,11 +16621,25 @@ declare namespace TailStream {
     readonly message: string;
     readonly stack?: string;
   }
-  interface Log {
+  interface TailStreamErrorInfo {
+    readonly name: string;
+    readonly message: string;
+    readonly stack?: string;
+  }
+  type Log = {
     readonly type: "log";
     readonly level: "debug" | "error" | "info" | "log" | "warn";
-    readonly message: object;
-  }
+    readonly errorInfo?: readonly (TailStreamErrorInfo | null)[];
+  } & (
+    | {
+        readonly message: object;
+        readonly truncated?: false;
+      }
+    | {
+        readonly message: string;
+        readonly truncated: true;
+      }
+  );
   interface DroppedEventsDiagnostic {
     readonly diagnosticsType: "droppedEvents";
     readonly count: number;
@@ -17046,7 +17175,25 @@ declare abstract class Workflow<PARAMS = unknown> {
   public createBatch(
     batch: WorkflowInstanceCreateOptions<PARAMS>[],
   ): Promise<WorkflowInstance[]>;
+  /**
+   * Delete a batch of Workflow instances and their stored state.
+   * `deleteBatch` is limited to 100 instances at a time. Duplicate IDs are deleted once.
+   * The result contains one entry for each input position; IDs that do not exist are returned as per-instance errors.
+   * @param instanceIds IDs of the Workflow instances to delete
+   * @returns A promise that resolves with the successfully deleted instances and any per-instance errors.
+   */
+  public deleteBatch(instanceIds: string[]): Promise<WorkflowBatchDeleteResult>;
 }
+type WorkflowBatchDeleteResult = {
+  deleted: {
+    id: string;
+  }[];
+  errors: {
+    id: string;
+    code: number;
+    message: string;
+  }[];
+};
 type WorkflowDurationLabel =
   | "second"
   | "minute"
@@ -17147,6 +17294,10 @@ declare abstract class WorkflowInstance {
    * @param options Options for the restart, including an optional step to restart from.
    */
   public restart(options?: WorkflowInstanceRestartOptions): Promise<void>;
+  /**
+   * Delete the instance and its stored state.
+   */
+  public delete(): Promise<void>;
   /**
    * Returns the current status of the instance.
    */

package/experimental/index.ts

@@ -505,6 +505,7 @@ export interface ExecutionContext<Props = unknown> {
     readonly override?: string;
   };
   readonly access?: CloudflareAccessContext;
+  mapVirtualHost(fetcher: Fetcher, port: number): string;
   tracing: Tracing;
   abort(reason?: any): void;
 }
@@ -3424,6 +3425,12 @@ export interface TraceLog {
   readonly timestamp: number;
   readonly level: string;
   readonly message: any;
+  readonly errorInfo?: (TraceLogErrorInfo | null)[];
+}
+export interface TraceLogErrorInfo {
+  name: string;
+  message: string;
+  stack?: string;
 }
 export interface TraceException {
   readonly timestamp: number;
@@ -3991,18 +3998,26 @@ export interface ContainerExecOptions {
   cwd?: string;
   env?: Record<string, string>;
   user?: string;
+  signal?: AbortSignal;
+  pty?: boolean | ContainerExecPtyOptions;
   stdin?: ReadableStream | "pipe";
   stdout?: "pipe" | "ignore";
   stderr?: "pipe" | "ignore" | "combined";
 }
+export interface ContainerExecPtyOptions {
+  cols?: number;
+  rows?: number;
+}
 export interface ExecProcess {
   readonly stdin: WritableStream | null;
   readonly stdout: ReadableStream | null;
   readonly stderr: ReadableStream | null;
   readonly pid: number;
+  readonly isPty: boolean;
   readonly exitCode: Promise<number>;
   output(): Promise<ExecOutput>;
   kill(signal?: number): void;
+  resize(cols: number, rows: number): void;
 }
 export interface Container {
   get running(): boolean;
@@ -4024,6 +4039,7 @@ export interface Container {
   exec(cmd: string[], options?: ContainerExecOptions): Promise<ExecProcess>;
   interceptOutboundTcp(addr: string, binding: Fetcher): Promise<void>;
   inspect(): Promise<ContainerInfo | null>;
+  setLabels(labels: Record<string, string>): Promise<void>;
 }
 export interface ContainerDirectorySnapshot {
   id: string;
@@ -4047,19 +4063,39 @@ export interface ContainerSnapshot {
 export interface ContainerSnapshotOptions {
   name?: string;
 }
-export interface ContainerStartupOptions {
+export type ContainerStartupOptions = {
   entrypoint?: string[];
   enableInternet: boolean;
   env?: Record<string, string>;
   hardTimeout?: number | bigint;
+  instance?:
+    | "lite"
+    | "standard-1"
+    | "standard-2"
+    | "standard-3"
+    | "standard-4"
+    | ContainerStartResources;
   labels?: Record<string, string>;
   directorySnapshots?: ContainerDirectorySnapshotRestoreParams[];
-  containerSnapshot?: ContainerSnapshot;
-}
+} & (
+  | {
+      image: string;
+      containerSnapshot?: never;
+    }
+  | {
+      image?: never;
+      containerSnapshot?: ContainerSnapshot;
+    }
+);
 export interface ContainerInfo {
   labels: Record<string, string>;
   image: string;
 }
+export interface ContainerStartResources {
+  vcpu: number;
+  memoryMib: number;
+  diskMb: number;
+}
 /**
  * The **`FileSystemHandle`** interface of the File System API is an object which represents a file or directory entry.
  * Available only in secure contexts.
@@ -4754,11 +4790,15 @@ export interface Tracing {
     callback: (span: Span, ...args: A) => T,
     ...args: A
   ): T;
+  startSpan(name: string): Span;
   Span: typeof Span;
 }
 export declare abstract class Span {
   get isTraced(): boolean;
-  setAttribute(key: string, value?: boolean | number | string): void;
+  setAttribute(key: string, value: boolean | number | string): this;
+  setAttributes(
+    attributes: Record<string, boolean | number | string | undefined>,
+  ): this;
   end(): void;
 }
 /**
@@ -5435,6 +5475,13 @@ export type AiSearchListItemsParams = {
   source?: string;
   /** JSON-encoded Vectorize filter for metadata filtering. */
   metadata_filter?: string;
+  /** Filter items by their unique ID. Returns at most one item. */
+  item_id?: string;
+  /**
+   * Filter items by their exact key (object key / filename). Keys are unique
+   * per source, so combine with `source` to disambiguate across data sources.
+   */
+  key?: string;
 };
 export type AiSearchListItemsResponse = {
   result: AiSearchItemInfo[];
@@ -14599,6 +14646,15 @@ export interface Hyperdrive {
    * for your database.
    */
   readonly host: string;
+  /*
+   * A synthetic IPv4 address (in the reserved 240.0.0.0/4 range) that, like the
+   * host field, is only valid within the context of the currently running
+   * Worker and, when passed into the `connect()` function from the
+   * "cloudflare:sockets" module, will connect to the Hyperdrive instance for
+   * your database. This is provided for database drivers that require the host
+   * to be an IP literal rather than a hostname.
+   */
+  readonly ip: string;
   /*
    * The port that must be paired the the host field when connecting.
    */
@@ -15388,6 +15444,32 @@ export declare namespace CloudflareWorkersModule {
     timeout?: WorkflowTimeoutDuration | number;
     sensitive?: WorkflowStepSensitivity;
   };
+  // Internal discriminators used only for `WorkflowStep.do` overload
+  // resolution. They mirror `WorkflowStepConfig` but pin `retries.delay` to a
+  // single kind so the callback context can be narrowed based on the shape of
+  // the config argument (rather than on an inferred type parameter, which is
+  // lost when the caller supplies an explicit return-type argument). Not
+  // exported: they must not widen the public type surface.
+  type WorkflowStepConfigWithStaticDelay = Omit<
+    WorkflowStepConfig,
+    "retries"
+  > & {
+    retries?: {
+      limit: number;
+      delay: WorkflowDelayDuration | number;
+      backoff?: WorkflowBackoff;
+    };
+  };
+  type WorkflowStepConfigWithDelayFunction = Omit<
+    WorkflowStepConfig,
+    "retries"
+  > & {
+    retries: {
+      limit: number;
+      delay: WorkflowDelayFunction;
+      backoff?: WorkflowBackoff;
+    };
+  };
   export type WorkflowStepRollbackConfig = Pick<
     WorkflowStepConfig,
     "retries" | "timeout"
@@ -15430,18 +15512,30 @@ export declare namespace CloudflareWorkersModule {
       sensitive?: WorkflowStepSensitivity;
     };
   };
-  export type WorkflowRollbackContext<T = unknown> = {
-    ctx: WorkflowStepContext;
+  // The rollback handler receives the step context, so it mirrors the same
+  // delay discriminant as the step callback: when the step was configured with
+  // a dynamic delay function the resolved `config.retries.delay` is omitted,
+  // otherwise it is present. `Delay` is threaded from the `WorkflowStep.do`
+  // overload that matched the step config.
+  export type WorkflowRollbackContext<
+    T = unknown,
+    Delay = WorkflowDelayDuration | number,
+  > = {
+    ctx: WorkflowStepContext<Delay>;
     error: Error;
     output: T | undefined;
     /** @deprecated Use `ctx.step.name` and `ctx.step.count` instead. */
     stepName: string;
   };
-  export type WorkflowRollbackHandler<T = unknown> = (
-    ctx: WorkflowRollbackContext<T>,
-  ) => Promise<void>;
-  export type WorkflowStepRollbackOptions<T = unknown> = {
-    rollback: WorkflowRollbackHandler<T>;
+  export type WorkflowRollbackHandler<
+    T = unknown,
+    Delay = WorkflowDelayDuration | number,
+  > = (ctx: WorkflowRollbackContext<T, Delay>) => Promise<void>;
+  export type WorkflowStepRollbackOptions<
+    T = unknown,
+    Delay = WorkflowDelayDuration | number,
+  > = {
+    rollback: WorkflowRollbackHandler<T, Delay>;
     rollbackConfig?: WorkflowStepRollbackConfig;
   };
   export abstract class WorkflowStep {
@@ -15450,18 +15544,34 @@ export declare namespace CloudflareWorkersModule {
       callback: (ctx: WorkflowStepContext) => Promise<T>,
       rollbackOptions?: WorkflowStepRollbackOptions<T>,
     ): Promise<T>;
-    do<T extends Rpc.Serializable<T>, const C extends WorkflowStepConfig>(
+    // The config overloads discriminate on the shape of `config.retries.delay`
+    // so the callback context reflects whether the resolved delay is present
+    // (static delay) or omitted (dynamic delay function). Each has a single
+    // type parameter, so an explicit return-type argument (`do<T>(...)`) still
+    // resolves here. ORDERING IS LOAD-BEARING: the broad `WorkflowStepConfig`
+    // fallback MUST remain last, otherwise it shadows the discriminating
+    // overloads and narrowing is silently lost.
+    do<T extends Rpc.Serializable<T>>(
       name: string,
-      config: C,
+      config: WorkflowStepConfigWithDelayFunction,
+      callback: (ctx: WorkflowStepContext<WorkflowDelayFunction>) => Promise<T>,
+      rollbackOptions?: WorkflowStepRollbackOptions<T, WorkflowDelayFunction>,
+    ): Promise<T>;
+    do<T extends Rpc.Serializable<T>>(
+      name: string,
+      config: WorkflowStepConfigWithStaticDelay,
       callback: (
-        ctx: WorkflowStepContext<
-          C["retries"] extends {
-            delay: infer D;
-          }
-            ? D
-            : WorkflowDelayDuration | number
-        >,
+        ctx: WorkflowStepContext<WorkflowDelayDuration | number>,
       ) => Promise<T>,
+      rollbackOptions?: WorkflowStepRollbackOptions<
+        T,
+        WorkflowDelayDuration | number
+      >,
+    ): Promise<T>;
+    do<T extends Rpc.Serializable<T>>(
+      name: string,
+      config: WorkflowStepConfig,
+      callback: (ctx: WorkflowStepContext) => Promise<T>,
       rollbackOptions?: WorkflowStepRollbackOptions<T>,
     ): Promise<T>;
     sleep: (name: string, duration: WorkflowSleepDuration) => Promise<void>;
@@ -16270,12 +16380,13 @@ export type MarkdownDocument = {
   name: string;
   blob: Blob;
 };
+export type OutputFormat = "markdown" | "text";
 export type ConversionResponse =
   | {
       id: string;
       name: string;
       mimeType: string;
-      format: "markdown";
+      format: OutputFormat;
       tokens: number;
       data: string;
     }
@@ -16293,7 +16404,11 @@ export type EmbeddedImageConversionOptions = ImageConversionOptions & {
   convert?: boolean;
   maxConvertedImages?: number;
 };
+export type ConversionOutputOptions = {
+  format?: OutputFormat;
+};
 export type ConversionOptions = {
+  output?: ConversionOutputOptions;
   html?: {
     images?: EmbeddedImageConversionOptions & {
       convertOGImage?: boolean;
@@ -16474,11 +16589,25 @@ export declare namespace TailStream {
     readonly message: string;
     readonly stack?: string;
   }
-  interface Log {
+  interface TailStreamErrorInfo {
+    readonly name: string;
+    readonly message: string;
+    readonly stack?: string;
+  }
+  type Log = {
     readonly type: "log";
     readonly level: "debug" | "error" | "info" | "log" | "warn";
-    readonly message: object;
-  }
+    readonly errorInfo?: readonly (TailStreamErrorInfo | null)[];
+  } & (
+    | {
+        readonly message: object;
+        readonly truncated?: false;
+      }
+    | {
+        readonly message: string;
+        readonly truncated: true;
+      }
+  );
   interface DroppedEventsDiagnostic {
     readonly diagnosticsType: "droppedEvents";
     readonly count: number;
@@ -17005,7 +17134,25 @@ export declare abstract class Workflow<PARAMS = unknown> {
   public createBatch(
     batch: WorkflowInstanceCreateOptions<PARAMS>[],
   ): Promise<WorkflowInstance[]>;
+  /**
+   * Delete a batch of Workflow instances and their stored state.
+   * `deleteBatch` is limited to 100 instances at a time. Duplicate IDs are deleted once.
+   * The result contains one entry for each input position; IDs that do not exist are returned as per-instance errors.
+   * @param instanceIds IDs of the Workflow instances to delete
+   * @returns A promise that resolves with the successfully deleted instances and any per-instance errors.
+   */
+  public deleteBatch(instanceIds: string[]): Promise<WorkflowBatchDeleteResult>;
 }
+export type WorkflowBatchDeleteResult = {
+  deleted: {
+    id: string;
+  }[];
+  errors: {
+    id: string;
+    code: number;
+    message: string;
+  }[];
+};
 export type WorkflowDurationLabel =
   | "second"
   | "minute"
@@ -17106,6 +17253,10 @@ export declare abstract class WorkflowInstance {
    * @param options Options for the restart, including an optional step to restart from.
    */
   public restart(options?: WorkflowInstanceRestartOptions): Promise<void>;
+  /**
+   * Delete the instance and its stored state.
+   */
+  public delete(): Promise<void>;
   /**
    * Returns the current status of the instance.
    */