@cloudflare/workers-types 4.20250124.3 → 4.20250129.0

package/2021-11-03/index.d.ts

@@ -538,6 +538,7 @@ interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3401,6 +3402,18 @@ interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 type AiImageClassificationInput = {
   image: number[];
 };
@@ -4097,6 +4110,7 @@ interface AiModels {
 }
 type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4131,11 +4145,17 @@ type AiModelListType = Record<string, any>;
 declare abstract class Ai<AiModelList extends AiModelListType = AiModels> {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 type GatewayOptions = {

package/2021-11-03/index.ts

@@ -543,6 +543,7 @@ export interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3413,6 +3414,18 @@ export interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+export interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+export interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 export type AiImageClassificationInput = {
   image: number[];
 };
@@ -4109,6 +4122,7 @@ export interface AiModels {
 }
 export type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4145,11 +4159,17 @@ export declare abstract class Ai<
 > {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 export type GatewayOptions = {

package/2022-01-31/index.d.ts

@@ -538,6 +538,7 @@ interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3427,6 +3428,18 @@ interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 type AiImageClassificationInput = {
   image: number[];
 };
@@ -4123,6 +4136,7 @@ interface AiModels {
 }
 type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4157,11 +4171,17 @@ type AiModelListType = Record<string, any>;
 declare abstract class Ai<AiModelList extends AiModelListType = AiModels> {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 type GatewayOptions = {

package/2022-01-31/index.ts

@@ -543,6 +543,7 @@ export interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3439,6 +3440,18 @@ export interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+export interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+export interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 export type AiImageClassificationInput = {
   image: number[];
 };
@@ -4135,6 +4148,7 @@ export interface AiModels {
 }
 export type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4171,11 +4185,17 @@ export declare abstract class Ai<
 > {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 export type GatewayOptions = {

package/2022-03-21/index.d.ts

@@ -556,6 +556,7 @@ interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3452,6 +3453,18 @@ interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 type AiImageClassificationInput = {
   image: number[];
 };
@@ -4148,6 +4161,7 @@ interface AiModels {
 }
 type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4182,11 +4196,17 @@ type AiModelListType = Record<string, any>;
 declare abstract class Ai<AiModelList extends AiModelListType = AiModels> {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 type GatewayOptions = {

package/2022-03-21/index.ts

@@ -561,6 +561,7 @@ export interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3464,6 +3465,18 @@ export interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+export interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+export interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 export type AiImageClassificationInput = {
   image: number[];
 };
@@ -4160,6 +4173,7 @@ export interface AiModels {
 }
 export type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4196,11 +4210,17 @@ export declare abstract class Ai<
 > {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 export type GatewayOptions = {

package/2022-08-04/index.d.ts

@@ -556,6 +556,7 @@ interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3453,6 +3454,18 @@ interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 type AiImageClassificationInput = {
   image: number[];
 };
@@ -4149,6 +4162,7 @@ interface AiModels {
 }
 type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4183,11 +4197,17 @@ type AiModelListType = Record<string, any>;
 declare abstract class Ai<AiModelList extends AiModelListType = AiModels> {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 type GatewayOptions = {

package/2022-08-04/index.ts

@@ -561,6 +561,7 @@ export interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3465,6 +3466,18 @@ export interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+export interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+export interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 export type AiImageClassificationInput = {
   image: number[];
 };
@@ -4161,6 +4174,7 @@ export interface AiModels {
 }
 export type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4197,11 +4211,17 @@ export declare abstract class Ai<
 > {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 export type GatewayOptions = {

package/2022-10-31/index.d.ts

@@ -556,6 +556,7 @@ interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3456,6 +3457,18 @@ interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 type AiImageClassificationInput = {
   image: number[];
 };
@@ -4152,6 +4165,7 @@ interface AiModels {
 }
 type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4186,11 +4200,17 @@ type AiModelListType = Record<string, any>;
 declare abstract class Ai<AiModelList extends AiModelListType = AiModels> {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 type GatewayOptions = {

package/2022-10-31/index.ts

@@ -561,6 +561,7 @@ export interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3468,6 +3469,18 @@ export interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+export interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+export interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 export type AiImageClassificationInput = {
   image: number[];
 };
@@ -4164,6 +4177,7 @@ export interface AiModels {
 }
 export type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4200,11 +4214,17 @@ export declare abstract class Ai<
 > {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 export type GatewayOptions = {

package/2022-11-30/index.d.ts

@@ -561,6 +561,7 @@ interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3461,6 +3462,18 @@ interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 type AiImageClassificationInput = {
   image: number[];
 };
@@ -4157,6 +4170,7 @@ interface AiModels {
 }
 type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4191,11 +4205,17 @@ type AiModelListType = Record<string, any>;
 declare abstract class Ai<AiModelList extends AiModelListType = AiModels> {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 type GatewayOptions = {

package/2022-11-30/index.ts

@@ -566,6 +566,7 @@ export interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3473,6 +3474,18 @@ export interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+export interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+export interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 export type AiImageClassificationInput = {
   image: number[];
 };
@@ -4169,6 +4182,7 @@ export interface AiModels {
 }
 export type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4205,11 +4219,17 @@ export declare abstract class Ai<
 > {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 export type GatewayOptions = {

package/2023-03-01/index.d.ts

@@ -561,6 +561,7 @@ interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3463,6 +3464,18 @@ interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 type AiImageClassificationInput = {
   image: number[];
 };
@@ -4159,6 +4172,7 @@ interface AiModels {
 }
 type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4193,11 +4207,17 @@ type AiModelListType = Record<string, any>;
 declare abstract class Ai<AiModelList extends AiModelListType = AiModels> {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 type GatewayOptions = {

package/2023-03-01/index.ts

@@ -566,6 +566,7 @@ export interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3475,6 +3476,18 @@ export interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+export interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+export interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 export type AiImageClassificationInput = {
   image: number[];
 };
@@ -4171,6 +4184,7 @@ export interface AiModels {
 }
 export type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4207,11 +4221,17 @@ export declare abstract class Ai<
 > {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 export type GatewayOptions = {

package/2023-07-01/index.d.ts

@@ -561,6 +561,7 @@ interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3463,6 +3464,18 @@ interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 type AiImageClassificationInput = {
   image: number[];
 };
@@ -4159,6 +4172,7 @@ interface AiModels {
 }
 type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4193,11 +4207,17 @@ type AiModelListType = Record<string, any>;
 declare abstract class Ai<AiModelList extends AiModelListType = AiModels> {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 type GatewayOptions = {

package/2023-07-01/index.ts

@@ -566,6 +566,7 @@ export interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3475,6 +3476,18 @@ export interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+export interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+export interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 export type AiImageClassificationInput = {
   image: number[];
 };
@@ -4171,6 +4184,7 @@ export interface AiModels {
 }
 export type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4207,11 +4221,17 @@ export declare abstract class Ai<
 > {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 export type GatewayOptions = {

package/experimental/index.d.ts

@@ -566,6 +566,7 @@ interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3542,6 +3543,18 @@ interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 type AiImageClassificationInput = {
   image: number[];
 };
@@ -4238,6 +4251,7 @@ interface AiModels {
 }
 type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4272,11 +4286,17 @@ type AiModelListType = Record<string, any>;
 declare abstract class Ai<AiModelList extends AiModelListType = AiModels> {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 type GatewayOptions = {

package/experimental/index.ts

@@ -571,6 +571,7 @@ export interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3554,6 +3555,18 @@ export interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+export interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+export interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 export type AiImageClassificationInput = {
   image: number[];
 };
@@ -4250,6 +4263,7 @@ export interface AiModels {
 }
 export type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4286,11 +4300,17 @@ export declare abstract class Ai<
 > {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 export type GatewayOptions = {

package/index.d.ts

@@ -538,6 +538,7 @@ interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3401,6 +3402,18 @@ interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 type AiImageClassificationInput = {
   image: number[];
 };
@@ -4097,6 +4110,7 @@ interface AiModels {
 }
 type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4131,11 +4145,17 @@ type AiModelListType = Record<string, any>;
 declare abstract class Ai<AiModelList extends AiModelListType = AiModels> {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 type GatewayOptions = {

package/index.ts

@@ -543,6 +543,7 @@ export interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3413,6 +3414,18 @@ export interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+export interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+export interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 export type AiImageClassificationInput = {
   image: number[];
 };
@@ -4109,6 +4122,7 @@ export interface AiModels {
 }
 export type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4145,11 +4159,17 @@ export declare abstract class Ai<
 > {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 export type GatewayOptions = {

package/oldest/index.d.ts

@@ -538,6 +538,7 @@ interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3401,6 +3402,18 @@ interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 type AiImageClassificationInput = {
   image: number[];
 };
@@ -4097,6 +4110,7 @@ interface AiModels {
 }
 type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4131,11 +4145,17 @@ type AiModelListType = Record<string, any>;
 declare abstract class Ai<AiModelList extends AiModelListType = AiModels> {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 type GatewayOptions = {

package/oldest/index.ts

@@ -543,6 +543,7 @@ export interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
+  container?: Container;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
   acceptWebSocket(ws: WebSocket, tags?: string[]): void;
   getWebSockets(tag?: string): WebSocket[];
@@ -3413,6 +3414,18 @@ export interface EventSourceEventSourceInit {
   withCredentials?: boolean;
   fetcher?: Fetcher;
 }
+export interface Container {
+  get running(): boolean;
+  start(options?: ContainerStartupOptions): void;
+  monitor(): Promise<void>;
+  destroy(error?: any): Promise<void>;
+  signal(signo: number): void;
+  getTcpPort(port: number): Fetcher;
+}
+export interface ContainerStartupOptions {
+  entrypoint?: string[];
+  enableInternet: boolean;
+}
 export type AiImageClassificationInput = {
   image: number[];
 };
@@ -4109,6 +4122,7 @@ export interface AiModels {
 }
 export type AiOptions = {
   gateway?: GatewayOptions;
+  returnRawResponse?: boolean;
   prefix?: string;
   extraHeaders?: object;
 };
@@ -4145,11 +4159,17 @@ export declare abstract class Ai<
 > {
   aiGatewayLogId: string | null;
   gateway(gatewayId: string): AiGateway;
-  run<Name extends keyof AiModelList>(
+  run<Name extends keyof AiModelList, Options extends AiOptions>(
     model: Name,
     inputs: AiModelList[Name]["inputs"],
-    options?: AiOptions,
-  ): Promise<AiModelList[Name]["postProcessedOutputs"]>;
+    options?: Options,
+  ): Promise<
+    Options extends {
+      returnRawResponse: true;
+    }
+      ? Response
+      : AiModelList[Name]["postProcessedOutputs"]
+  >;
   public models(params?: AiModelsSearchParams): Promise<AiModelsSearchObject[]>;
 }
 export type GatewayOptions = {

package/package.json

@@ -7,5 +7,5 @@
   },
   "author": "Cloudflare Workers DevProd Team <workers-devprod@cloudflare.com> (https://workers.cloudflare.com)",
   "license": "MIT OR Apache-2.0",
-  "version": "4.20250124.3"
+  "version": "4.20250129.0"
 }