@cloudflare/workers-types 4.20260307.1 → 4.20260312.1

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

@@ -469,54 +469,63 @@ interface ExecutionContext<Props = unknown> {
   passThroughOnException(): void;
   readonly props: Props;
 }
-type ExportedHandlerFetchHandler<Env = unknown, CfHostMetadata = unknown> = (
+type ExportedHandlerFetchHandler<
+  Env = unknown,
+  CfHostMetadata = unknown,
+  Props = unknown,
+> = (
   request: Request<CfHostMetadata, IncomingRequestCfProperties<CfHostMetadata>>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => Response | Promise<Response>;
-type ExportedHandlerTailHandler<Env = unknown> = (
+type ExportedHandlerTailHandler<Env = unknown, Props = unknown> = (
   events: TraceItem[],
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerTraceHandler<Env = unknown> = (
+type ExportedHandlerTraceHandler<Env = unknown, Props = unknown> = (
   traces: TraceItem[],
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerTailStreamHandler<Env = unknown> = (
+type ExportedHandlerTailStreamHandler<Env = unknown, Props = unknown> = (
   event: TailStream.TailEvent<TailStream.Onset>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => TailStream.TailEventHandlerType | Promise<TailStream.TailEventHandlerType>;
-type ExportedHandlerScheduledHandler<Env = unknown> = (
+type ExportedHandlerScheduledHandler<Env = unknown, Props = unknown> = (
   controller: ScheduledController,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerQueueHandler<Env = unknown, Message = unknown> = (
+type ExportedHandlerQueueHandler<
+  Env = unknown,
+  Message = unknown,
+  Props = unknown,
+> = (
   batch: MessageBatch<Message>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerTestHandler<Env = unknown> = (
+type ExportedHandlerTestHandler<Env = unknown, Props = unknown> = (
   controller: TestController,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
 interface ExportedHandler<
   Env = unknown,
   QueueHandlerMessage = unknown,
   CfHostMetadata = unknown,
+  Props = unknown,
 > {
-  fetch?: ExportedHandlerFetchHandler<Env, CfHostMetadata>;
-  tail?: ExportedHandlerTailHandler<Env>;
-  trace?: ExportedHandlerTraceHandler<Env>;
-  tailStream?: ExportedHandlerTailStreamHandler<Env>;
-  scheduled?: ExportedHandlerScheduledHandler<Env>;
-  test?: ExportedHandlerTestHandler<Env>;
-  email?: EmailExportedHandler<Env>;
-  queue?: ExportedHandlerQueueHandler<Env, QueueHandlerMessage>;
+  fetch?: ExportedHandlerFetchHandler<Env, CfHostMetadata, Props>;
+  tail?: ExportedHandlerTailHandler<Env, Props>;
+  trace?: ExportedHandlerTraceHandler<Env, Props>;
+  tailStream?: ExportedHandlerTailStreamHandler<Env, Props>;
+  scheduled?: ExportedHandlerScheduledHandler<Env, Props>;
+  test?: ExportedHandlerTestHandler<Env, Props>;
+  email?: EmailExportedHandler<Env, Props>;
+  queue?: ExportedHandlerQueueHandler<Env, QueueHandlerMessage, Props>;
 }
 interface StructuredSerializeOptions {
   transfer?: any[];
@@ -3454,7 +3463,7 @@ declare var WebSocket: {
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket)
  */
 interface WebSocket extends EventTarget<WebSocketEventMap> {
-  accept(): void;
+  accept(options?: WebSocketAcceptOptions): void;
   /**
    * The **`WebSocket.send()`** method enqueues the specified data to be transmitted to the server over the WebSocket connection, increasing the value of `bufferedAmount` by the number of bytes needed to contain the data.
    *
@@ -3500,6 +3509,16 @@ interface WebSocket extends EventTarget<WebSocketEventMap> {
    */
   binaryType: "blob" | "arraybuffer";
 }
+interface WebSocketAcceptOptions {
+  /**
+   * When set to `true`, receiving a server-initiated WebSocket Close frame will not
+   * automatically send a reciprocal Close frame, leaving the connection in a half-open
+   * state. This is useful for proxying scenarios where you need to coordinate closing
+   * both sides independently. Defaults to `false` when the
+   * `no_web_socket_half_open_by_default` compatibility flag is enabled.
+   */
+  allowHalfOpen?: boolean;
+}
 declare const WebSocketPair: {
   new (): {
     0: WebSocket;
@@ -3623,6 +3642,8 @@ interface Container {
   signal(signo: number): void;
   getTcpPort(port: number): Fetcher;
   setInactivityTimeout(durationMs: number | bigint): Promise<void>;
+  interceptOutboundHttp(addr: string, binding: Fetcher): Promise<void>;
+  interceptAllOutboundHttp(binding: Fetcher): Promise<void>;
 }
 interface ContainerStartupOptions {
   entrypoint?: string[];
@@ -10991,10 +11012,10 @@ interface SendEmail {
 declare abstract class EmailEvent extends ExtendableEvent {
   readonly message: ForwardableEmailMessage;
 }
-declare type EmailExportedHandler<Env = unknown> = (
+declare type EmailExportedHandler<Env = unknown, Props = unknown> = (
   message: ForwardableEmailMessage,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
 declare module "cloudflare:email" {
   let _EmailMessage: {

package/2021-11-03/index.ts

@@ -474,54 +474,60 @@ export interface ExecutionContext<Props = unknown> {
 export type ExportedHandlerFetchHandler<
   Env = unknown,
   CfHostMetadata = unknown,
+  Props = unknown,
 > = (
   request: Request<CfHostMetadata, IncomingRequestCfProperties<CfHostMetadata>>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => Response | Promise<Response>;
-export type ExportedHandlerTailHandler<Env = unknown> = (
+export type ExportedHandlerTailHandler<Env = unknown, Props = unknown> = (
   events: TraceItem[],
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-export type ExportedHandlerTraceHandler<Env = unknown> = (
+export type ExportedHandlerTraceHandler<Env = unknown, Props = unknown> = (
   traces: TraceItem[],
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-export type ExportedHandlerTailStreamHandler<Env = unknown> = (
+export type ExportedHandlerTailStreamHandler<Env = unknown, Props = unknown> = (
   event: TailStream.TailEvent<TailStream.Onset>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => TailStream.TailEventHandlerType | Promise<TailStream.TailEventHandlerType>;
-export type ExportedHandlerScheduledHandler<Env = unknown> = (
+export type ExportedHandlerScheduledHandler<Env = unknown, Props = unknown> = (
   controller: ScheduledController,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-export type ExportedHandlerQueueHandler<Env = unknown, Message = unknown> = (
+export type ExportedHandlerQueueHandler<
+  Env = unknown,
+  Message = unknown,
+  Props = unknown,
+> = (
   batch: MessageBatch<Message>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-export type ExportedHandlerTestHandler<Env = unknown> = (
+export type ExportedHandlerTestHandler<Env = unknown, Props = unknown> = (
   controller: TestController,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
 export interface ExportedHandler<
   Env = unknown,
   QueueHandlerMessage = unknown,
   CfHostMetadata = unknown,
+  Props = unknown,
 > {
-  fetch?: ExportedHandlerFetchHandler<Env, CfHostMetadata>;
-  tail?: ExportedHandlerTailHandler<Env>;
-  trace?: ExportedHandlerTraceHandler<Env>;
-  tailStream?: ExportedHandlerTailStreamHandler<Env>;
-  scheduled?: ExportedHandlerScheduledHandler<Env>;
-  test?: ExportedHandlerTestHandler<Env>;
-  email?: EmailExportedHandler<Env>;
-  queue?: ExportedHandlerQueueHandler<Env, QueueHandlerMessage>;
+  fetch?: ExportedHandlerFetchHandler<Env, CfHostMetadata, Props>;
+  tail?: ExportedHandlerTailHandler<Env, Props>;
+  trace?: ExportedHandlerTraceHandler<Env, Props>;
+  tailStream?: ExportedHandlerTailStreamHandler<Env, Props>;
+  scheduled?: ExportedHandlerScheduledHandler<Env, Props>;
+  test?: ExportedHandlerTestHandler<Env, Props>;
+  email?: EmailExportedHandler<Env, Props>;
+  queue?: ExportedHandlerQueueHandler<Env, QueueHandlerMessage, Props>;
 }
 export interface StructuredSerializeOptions {
   transfer?: any[];
@@ -3463,7 +3469,7 @@ export declare var WebSocket: {
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket)
  */
 export interface WebSocket extends EventTarget<WebSocketEventMap> {
-  accept(): void;
+  accept(options?: WebSocketAcceptOptions): void;
   /**
    * The **`WebSocket.send()`** method enqueues the specified data to be transmitted to the server over the WebSocket connection, increasing the value of `bufferedAmount` by the number of bytes needed to contain the data.
    *
@@ -3509,6 +3515,16 @@ export interface WebSocket extends EventTarget<WebSocketEventMap> {
    */
   binaryType: "blob" | "arraybuffer";
 }
+export interface WebSocketAcceptOptions {
+  /**
+   * When set to `true`, receiving a server-initiated WebSocket Close frame will not
+   * automatically send a reciprocal Close frame, leaving the connection in a half-open
+   * state. This is useful for proxying scenarios where you need to coordinate closing
+   * both sides independently. Defaults to `false` when the
+   * `no_web_socket_half_open_by_default` compatibility flag is enabled.
+   */
+  allowHalfOpen?: boolean;
+}
 export declare const WebSocketPair: {
   new (): {
     0: WebSocket;
@@ -3632,6 +3648,8 @@ export interface Container {
   signal(signo: number): void;
   getTcpPort(port: number): Fetcher;
   setInactivityTimeout(durationMs: number | bigint): Promise<void>;
+  interceptOutboundHttp(addr: string, binding: Fetcher): Promise<void>;
+  interceptAllOutboundHttp(binding: Fetcher): Promise<void>;
 }
 export interface ContainerStartupOptions {
   entrypoint?: string[];
@@ -11015,10 +11033,10 @@ export interface SendEmail {
 export declare abstract class EmailEvent extends ExtendableEvent {
   readonly message: ForwardableEmailMessage;
 }
-export declare type EmailExportedHandler<Env = unknown> = (
+export declare type EmailExportedHandler<Env = unknown, Props = unknown> = (
   message: ForwardableEmailMessage,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
 /**
  * Hello World binding to serve as an explanatory example. DO NOT USE

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

@@ -469,54 +469,63 @@ interface ExecutionContext<Props = unknown> {
   passThroughOnException(): void;
   readonly props: Props;
 }
-type ExportedHandlerFetchHandler<Env = unknown, CfHostMetadata = unknown> = (
+type ExportedHandlerFetchHandler<
+  Env = unknown,
+  CfHostMetadata = unknown,
+  Props = unknown,
+> = (
   request: Request<CfHostMetadata, IncomingRequestCfProperties<CfHostMetadata>>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => Response | Promise<Response>;
-type ExportedHandlerTailHandler<Env = unknown> = (
+type ExportedHandlerTailHandler<Env = unknown, Props = unknown> = (
   events: TraceItem[],
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerTraceHandler<Env = unknown> = (
+type ExportedHandlerTraceHandler<Env = unknown, Props = unknown> = (
   traces: TraceItem[],
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerTailStreamHandler<Env = unknown> = (
+type ExportedHandlerTailStreamHandler<Env = unknown, Props = unknown> = (
   event: TailStream.TailEvent<TailStream.Onset>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => TailStream.TailEventHandlerType | Promise<TailStream.TailEventHandlerType>;
-type ExportedHandlerScheduledHandler<Env = unknown> = (
+type ExportedHandlerScheduledHandler<Env = unknown, Props = unknown> = (
   controller: ScheduledController,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerQueueHandler<Env = unknown, Message = unknown> = (
+type ExportedHandlerQueueHandler<
+  Env = unknown,
+  Message = unknown,
+  Props = unknown,
+> = (
   batch: MessageBatch<Message>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerTestHandler<Env = unknown> = (
+type ExportedHandlerTestHandler<Env = unknown, Props = unknown> = (
   controller: TestController,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
 interface ExportedHandler<
   Env = unknown,
   QueueHandlerMessage = unknown,
   CfHostMetadata = unknown,
+  Props = unknown,
 > {
-  fetch?: ExportedHandlerFetchHandler<Env, CfHostMetadata>;
-  tail?: ExportedHandlerTailHandler<Env>;
-  trace?: ExportedHandlerTraceHandler<Env>;
-  tailStream?: ExportedHandlerTailStreamHandler<Env>;
-  scheduled?: ExportedHandlerScheduledHandler<Env>;
-  test?: ExportedHandlerTestHandler<Env>;
-  email?: EmailExportedHandler<Env>;
-  queue?: ExportedHandlerQueueHandler<Env, QueueHandlerMessage>;
+  fetch?: ExportedHandlerFetchHandler<Env, CfHostMetadata, Props>;
+  tail?: ExportedHandlerTailHandler<Env, Props>;
+  trace?: ExportedHandlerTraceHandler<Env, Props>;
+  tailStream?: ExportedHandlerTailStreamHandler<Env, Props>;
+  scheduled?: ExportedHandlerScheduledHandler<Env, Props>;
+  test?: ExportedHandlerTestHandler<Env, Props>;
+  email?: EmailExportedHandler<Env, Props>;
+  queue?: ExportedHandlerQueueHandler<Env, QueueHandlerMessage, Props>;
 }
 interface StructuredSerializeOptions {
   transfer?: any[];
@@ -3521,7 +3530,7 @@ declare var WebSocket: {
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket)
  */
 interface WebSocket extends EventTarget<WebSocketEventMap> {
-  accept(): void;
+  accept(options?: WebSocketAcceptOptions): void;
   /**
    * The **`WebSocket.send()`** method enqueues the specified data to be transmitted to the server over the WebSocket connection, increasing the value of `bufferedAmount` by the number of bytes needed to contain the data.
    *
@@ -3567,6 +3576,16 @@ interface WebSocket extends EventTarget<WebSocketEventMap> {
    */
   binaryType: "blob" | "arraybuffer";
 }
+interface WebSocketAcceptOptions {
+  /**
+   * When set to `true`, receiving a server-initiated WebSocket Close frame will not
+   * automatically send a reciprocal Close frame, leaving the connection in a half-open
+   * state. This is useful for proxying scenarios where you need to coordinate closing
+   * both sides independently. Defaults to `false` when the
+   * `no_web_socket_half_open_by_default` compatibility flag is enabled.
+   */
+  allowHalfOpen?: boolean;
+}
 declare const WebSocketPair: {
   new (): {
     0: WebSocket;
@@ -3690,6 +3709,8 @@ interface Container {
   signal(signo: number): void;
   getTcpPort(port: number): Fetcher;
   setInactivityTimeout(durationMs: number | bigint): Promise<void>;
+  interceptOutboundHttp(addr: string, binding: Fetcher): Promise<void>;
+  interceptAllOutboundHttp(binding: Fetcher): Promise<void>;
 }
 interface ContainerStartupOptions {
   entrypoint?: string[];
@@ -11058,10 +11079,10 @@ interface SendEmail {
 declare abstract class EmailEvent extends ExtendableEvent {
   readonly message: ForwardableEmailMessage;
 }
-declare type EmailExportedHandler<Env = unknown> = (
+declare type EmailExportedHandler<Env = unknown, Props = unknown> = (
   message: ForwardableEmailMessage,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
 declare module "cloudflare:email" {
   let _EmailMessage: {

package/2022-01-31/index.ts

@@ -474,54 +474,60 @@ export interface ExecutionContext<Props = unknown> {
 export type ExportedHandlerFetchHandler<
   Env = unknown,
   CfHostMetadata = unknown,
+  Props = unknown,
 > = (
   request: Request<CfHostMetadata, IncomingRequestCfProperties<CfHostMetadata>>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => Response | Promise<Response>;
-export type ExportedHandlerTailHandler<Env = unknown> = (
+export type ExportedHandlerTailHandler<Env = unknown, Props = unknown> = (
   events: TraceItem[],
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-export type ExportedHandlerTraceHandler<Env = unknown> = (
+export type ExportedHandlerTraceHandler<Env = unknown, Props = unknown> = (
   traces: TraceItem[],
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-export type ExportedHandlerTailStreamHandler<Env = unknown> = (
+export type ExportedHandlerTailStreamHandler<Env = unknown, Props = unknown> = (
   event: TailStream.TailEvent<TailStream.Onset>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => TailStream.TailEventHandlerType | Promise<TailStream.TailEventHandlerType>;
-export type ExportedHandlerScheduledHandler<Env = unknown> = (
+export type ExportedHandlerScheduledHandler<Env = unknown, Props = unknown> = (
   controller: ScheduledController,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-export type ExportedHandlerQueueHandler<Env = unknown, Message = unknown> = (
+export type ExportedHandlerQueueHandler<
+  Env = unknown,
+  Message = unknown,
+  Props = unknown,
+> = (
   batch: MessageBatch<Message>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-export type ExportedHandlerTestHandler<Env = unknown> = (
+export type ExportedHandlerTestHandler<Env = unknown, Props = unknown> = (
   controller: TestController,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
 export interface ExportedHandler<
   Env = unknown,
   QueueHandlerMessage = unknown,
   CfHostMetadata = unknown,
+  Props = unknown,
 > {
-  fetch?: ExportedHandlerFetchHandler<Env, CfHostMetadata>;
-  tail?: ExportedHandlerTailHandler<Env>;
-  trace?: ExportedHandlerTraceHandler<Env>;
-  tailStream?: ExportedHandlerTailStreamHandler<Env>;
-  scheduled?: ExportedHandlerScheduledHandler<Env>;
-  test?: ExportedHandlerTestHandler<Env>;
-  email?: EmailExportedHandler<Env>;
-  queue?: ExportedHandlerQueueHandler<Env, QueueHandlerMessage>;
+  fetch?: ExportedHandlerFetchHandler<Env, CfHostMetadata, Props>;
+  tail?: ExportedHandlerTailHandler<Env, Props>;
+  trace?: ExportedHandlerTraceHandler<Env, Props>;
+  tailStream?: ExportedHandlerTailStreamHandler<Env, Props>;
+  scheduled?: ExportedHandlerScheduledHandler<Env, Props>;
+  test?: ExportedHandlerTestHandler<Env, Props>;
+  email?: EmailExportedHandler<Env, Props>;
+  queue?: ExportedHandlerQueueHandler<Env, QueueHandlerMessage, Props>;
 }
 export interface StructuredSerializeOptions {
   transfer?: any[];
@@ -3530,7 +3536,7 @@ export declare var WebSocket: {
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket)
  */
 export interface WebSocket extends EventTarget<WebSocketEventMap> {
-  accept(): void;
+  accept(options?: WebSocketAcceptOptions): void;
   /**
    * The **`WebSocket.send()`** method enqueues the specified data to be transmitted to the server over the WebSocket connection, increasing the value of `bufferedAmount` by the number of bytes needed to contain the data.
    *
@@ -3576,6 +3582,16 @@ export interface WebSocket extends EventTarget<WebSocketEventMap> {
    */
   binaryType: "blob" | "arraybuffer";
 }
+export interface WebSocketAcceptOptions {
+  /**
+   * When set to `true`, receiving a server-initiated WebSocket Close frame will not
+   * automatically send a reciprocal Close frame, leaving the connection in a half-open
+   * state. This is useful for proxying scenarios where you need to coordinate closing
+   * both sides independently. Defaults to `false` when the
+   * `no_web_socket_half_open_by_default` compatibility flag is enabled.
+   */
+  allowHalfOpen?: boolean;
+}
 export declare const WebSocketPair: {
   new (): {
     0: WebSocket;
@@ -3699,6 +3715,8 @@ export interface Container {
   signal(signo: number): void;
   getTcpPort(port: number): Fetcher;
   setInactivityTimeout(durationMs: number | bigint): Promise<void>;
+  interceptOutboundHttp(addr: string, binding: Fetcher): Promise<void>;
+  interceptAllOutboundHttp(binding: Fetcher): Promise<void>;
 }
 export interface ContainerStartupOptions {
   entrypoint?: string[];
@@ -11082,10 +11100,10 @@ export interface SendEmail {
 export declare abstract class EmailEvent extends ExtendableEvent {
   readonly message: ForwardableEmailMessage;
 }
-export declare type EmailExportedHandler<Env = unknown> = (
+export declare type EmailExportedHandler<Env = unknown, Props = unknown> = (
   message: ForwardableEmailMessage,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
 /**
  * Hello World binding to serve as an explanatory example. DO NOT USE

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

@@ -472,54 +472,63 @@ interface ExecutionContext<Props = unknown> {
   passThroughOnException(): void;
   readonly props: Props;
 }
-type ExportedHandlerFetchHandler<Env = unknown, CfHostMetadata = unknown> = (
+type ExportedHandlerFetchHandler<
+  Env = unknown,
+  CfHostMetadata = unknown,
+  Props = unknown,
+> = (
   request: Request<CfHostMetadata, IncomingRequestCfProperties<CfHostMetadata>>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => Response | Promise<Response>;
-type ExportedHandlerTailHandler<Env = unknown> = (
+type ExportedHandlerTailHandler<Env = unknown, Props = unknown> = (
   events: TraceItem[],
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerTraceHandler<Env = unknown> = (
+type ExportedHandlerTraceHandler<Env = unknown, Props = unknown> = (
   traces: TraceItem[],
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerTailStreamHandler<Env = unknown> = (
+type ExportedHandlerTailStreamHandler<Env = unknown, Props = unknown> = (
   event: TailStream.TailEvent<TailStream.Onset>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => TailStream.TailEventHandlerType | Promise<TailStream.TailEventHandlerType>;
-type ExportedHandlerScheduledHandler<Env = unknown> = (
+type ExportedHandlerScheduledHandler<Env = unknown, Props = unknown> = (
   controller: ScheduledController,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerQueueHandler<Env = unknown, Message = unknown> = (
+type ExportedHandlerQueueHandler<
+  Env = unknown,
+  Message = unknown,
+  Props = unknown,
+> = (
   batch: MessageBatch<Message>,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
-type ExportedHandlerTestHandler<Env = unknown> = (
+type ExportedHandlerTestHandler<Env = unknown, Props = unknown> = (
   controller: TestController,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
 interface ExportedHandler<
   Env = unknown,
   QueueHandlerMessage = unknown,
   CfHostMetadata = unknown,
+  Props = unknown,
 > {
-  fetch?: ExportedHandlerFetchHandler<Env, CfHostMetadata>;
-  tail?: ExportedHandlerTailHandler<Env>;
-  trace?: ExportedHandlerTraceHandler<Env>;
-  tailStream?: ExportedHandlerTailStreamHandler<Env>;
-  scheduled?: ExportedHandlerScheduledHandler<Env>;
-  test?: ExportedHandlerTestHandler<Env>;
-  email?: EmailExportedHandler<Env>;
-  queue?: ExportedHandlerQueueHandler<Env, QueueHandlerMessage>;
+  fetch?: ExportedHandlerFetchHandler<Env, CfHostMetadata, Props>;
+  tail?: ExportedHandlerTailHandler<Env, Props>;
+  trace?: ExportedHandlerTraceHandler<Env, Props>;
+  tailStream?: ExportedHandlerTailStreamHandler<Env, Props>;
+  scheduled?: ExportedHandlerScheduledHandler<Env, Props>;
+  test?: ExportedHandlerTestHandler<Env, Props>;
+  email?: EmailExportedHandler<Env, Props>;
+  queue?: ExportedHandlerQueueHandler<Env, QueueHandlerMessage, Props>;
 }
 interface StructuredSerializeOptions {
   transfer?: any[];
@@ -3529,7 +3538,7 @@ declare var WebSocket: {
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket)
  */
 interface WebSocket extends EventTarget<WebSocketEventMap> {
-  accept(): void;
+  accept(options?: WebSocketAcceptOptions): void;
   /**
    * The **`WebSocket.send()`** method enqueues the specified data to be transmitted to the server over the WebSocket connection, increasing the value of `bufferedAmount` by the number of bytes needed to contain the data.
    *
@@ -3575,6 +3584,16 @@ interface WebSocket extends EventTarget<WebSocketEventMap> {
    */
   binaryType: "blob" | "arraybuffer";
 }
+interface WebSocketAcceptOptions {
+  /**
+   * When set to `true`, receiving a server-initiated WebSocket Close frame will not
+   * automatically send a reciprocal Close frame, leaving the connection in a half-open
+   * state. This is useful for proxying scenarios where you need to coordinate closing
+   * both sides independently. Defaults to `false` when the
+   * `no_web_socket_half_open_by_default` compatibility flag is enabled.
+   */
+  allowHalfOpen?: boolean;
+}
 declare const WebSocketPair: {
   new (): {
     0: WebSocket;
@@ -3698,6 +3717,8 @@ interface Container {
   signal(signo: number): void;
   getTcpPort(port: number): Fetcher;
   setInactivityTimeout(durationMs: number | bigint): Promise<void>;
+  interceptOutboundHttp(addr: string, binding: Fetcher): Promise<void>;
+  interceptAllOutboundHttp(binding: Fetcher): Promise<void>;
 }
 interface ContainerStartupOptions {
   entrypoint?: string[];
@@ -11066,10 +11087,10 @@ interface SendEmail {
 declare abstract class EmailEvent extends ExtendableEvent {
   readonly message: ForwardableEmailMessage;
 }
-declare type EmailExportedHandler<Env = unknown> = (
+declare type EmailExportedHandler<Env = unknown, Props = unknown> = (
   message: ForwardableEmailMessage,
   env: Env,
-  ctx: ExecutionContext,
+  ctx: ExecutionContext<Props>,
 ) => void | Promise<void>;
 declare module "cloudflare:email" {
   let _EmailMessage: {