import { a as BindingService, c as WorkerConfig, i as BindingNotFoundError, l as WorkerEnv, o as BindingValidationError, s as Binding_d_exports, t as Hyperdrive_d_exports, u as WorkerEnvironment } from "./Hyperdrive-C0vfrPeG.mjs";
import { Cause, Config, Context, Data, DateTime, Duration, Effect, Layer, Option, Redacted, Schema, Scope } from "effect";
import { Headers as Headers$1, HttpClient, HttpClientResponse, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
import { D1Client } from "@effect/sql-d1";
import { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, WorkflowEntrypoint, WorkflowEvent, WorkflowSleepDuration, WorkflowStep, WorkflowStepConfig, WorkflowStepContext, WorkflowStepEvent, WorkflowTimeoutDuration } from "cloudflare:workers";
import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
import * as RpcServer from "effect/unstable/rpc/RpcServer";
import { SqliteClient } from "@effect/sql-sqlite-do";
import * as _$effect_unstable_sql_SqlClient0 from "effect/unstable/sql/SqlClient";
import * as _$effect_Types0 from "effect/Types";
import * as _$effect_Cause0 from "effect/Cause";
import * as _$effect_Layer0 from "effect/Layer";
import * as _$effect_Scope0 from "effect/Scope";
import * as Tracer from "effect/Tracer";
import * as _$effect_Config0 from "effect/Config";

//#region src/WorkersAi.d.ts
declare namespace WorkersAi_d_exports {
  export { LayerOptions$18 as LayerOptions, Tag$17 as Tag, TagClass$16 as TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer$15 as layer, make$16 as make, makeClient$12 as makeClient };
}
declare const WorkersAiOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "WorkersAiOperationError";
} & Readonly<A>;
/** Error raised when a Workers AI operation fails. */
declare class WorkersAiOperationError extends WorkersAiOperationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly cause: unknown;
}> {}
/** Typed Workers AI binding definition. */
interface WorkersAiDefinition {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
}
type WorkersAiBinding<ModelList extends AiModelListType = AiModels> = CloudflareAi<ModelList>;
type WorkersAiOptions = AiOptions;
type WorkersAiModelsSearchParams = AiModelsSearchParams;
type WorkersAiModelsSearchObject = AiModelsSearchObject;
type WorkersAiAsyncBatchResponse = AiAsyncBatchResponse;
type WorkersAiEmbeddingInput = AiTextEmbeddingsInput | Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input | Record<string, unknown>;
interface WorkersAiEmbeddingResponse {
  readonly data: ReadonlyArray<ReadonlyArray<number>>;
  readonly shape: ReadonlyArray<number>;
}
interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
  readonly aiGatewayLogId: Effect.Effect<string | null, WorkersAiOperationError>;
  readonly run: {
    <Name extends keyof ModelList>(model: Name, input: {
      readonly requests: ReadonlyArray<ModelList[Name]["inputs"]>;
    }, options: WorkersAiOptions & {
      readonly queueRequest: true;
    }): Effect.Effect<WorkersAiAsyncBatchResponse, WorkersAiOperationError>;
    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"], options: WorkersAiOptions & {
      readonly returnRawResponse: true;
    }): Effect.Effect<Response, WorkersAiOperationError>;
    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"], options: WorkersAiOptions & {
      readonly websocket: true;
    }): Effect.Effect<Response, WorkersAiOperationError>;
    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"] & {
      readonly stream: true;
    }, options?: WorkersAiOptions): Effect.Effect<ReadableStream, WorkersAiOperationError>;
    <Name extends keyof ModelList>(model: Name, input: ModelList[Name]["inputs"], options?: WorkersAiOptions): Effect.Effect<ModelList[Name]["postProcessedOutputs"], WorkersAiOperationError>;
    <Input extends Record<string, unknown>, Output = Record<string, unknown>>(model: string, input: Input, options?: WorkersAiOptions): Effect.Effect<Output, WorkersAiOperationError>;
  };
  readonly runEmbedding: <Input extends WorkersAiEmbeddingInput>(model: string, input: Input, options?: WorkersAiOptions) => Effect.Effect<WorkersAiEmbeddingResponse, WorkersAiOperationError>;
  readonly models: (params?: WorkersAiModelsSearchParams) => Effect.Effect<ReadonlyArray<WorkersAiModelsSearchObject>, WorkersAiOperationError>;
  readonly gateway: (gatewayId: string) => Effect.Effect<CloudflareAiGateway, WorkersAiOperationError>;
  readonly unsafeRaw: Effect.Effect<WorkersAiBinding<ModelList>>;
  readonly definition: WorkersAiDefinition;
}
declare const WorkersAiServiceTypeId: unique symbol;
/** Nominal service marker for Workers AI services created with {@link make}. */
interface WorkersAiService<Id extends string> {
  readonly [WorkersAiServiceTypeId]: {
    readonly id: Id;
  };
}
type LayerOptions$18 = {
  readonly binding: string;
};
interface TagClass$16<Self, Id extends string, ModelList extends AiModelListType = AiModels> extends Context.ServiceClass<Self, Id, WorkersAiClient<ModelList>> {
  readonly id: Id;
  readonly layer: (options: LayerOptions$18) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
}
declare const isWorkersAiBinding: (value: unknown) => value is WorkersAiBinding;
declare const embeddingResponse: (value: {
  readonly data?: ReadonlyArray<ReadonlyArray<number>>;
  readonly shape?: ReadonlyArray<number>;
}) => WorkersAiEmbeddingResponse;
declare const makeClient$12: <ModelList extends AiModelListType = AiModels>(definition: WorkersAiDefinition) => (ai: WorkersAiBinding<ModelList>) => WorkersAiClient<ModelList>;
declare const layer$15: <Self, ModelList extends AiModelListType = AiModels>(tag: Context.Service<Self, WorkersAiClient<ModelList>>, definition: WorkersAiDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare const make$16: <Id extends string>(id: Id) => TagClass$16<WorkersAiService<Id>, Id, AiModels>;
declare const Tag$17: <Self>() => <Id extends string, ModelList extends AiModelListType = AiModels>(id: Id) => TagClass$16<Self, Id, ModelList>;
declare namespace AiGateway_d_exports {
  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions$17 as LayerOptions, Tag$16 as Tag, TagClass$15 as TagClass, isAiGatewayBinding, layer$14 as layer, make$15 as make, makeClient$11 as makeClient, makeClientFromAi, makeHttpClient };
}
declare const AiGatewayOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "AiGatewayOperationError";
} & Readonly<A>;
/** Error raised when an AI Gateway operation fails. */
declare class AiGatewayOperationError extends AiGatewayOperationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly cause: unknown;
}> {}
/** Typed AI Gateway client definition. */
interface AiGatewayDefinition {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
  /** Gateway id/name passed to `env.AI.gateway(id)`. */
  readonly gatewayId: string;
  /** Optional account id used by the HTTP-only helper. */
  readonly accountId?: string;
}
type AiGatewayBinding = CloudflareAiGateway;
type AiGatewayRunData = Parameters<AiGatewayBinding["run"]>[0];
type AiGatewayPatchLog = Parameters<AiGatewayBinding["patchLog"]>[1];
type AiGatewayLog = Awaited<ReturnType<AiGatewayBinding["getLog"]>>;
type AiGatewayProvider = NonNullable<Parameters<AiGatewayBinding["getUrl"]>[0]>;
type AiGatewayUniversalRequest = Exclude<AiGatewayRunData, ReadonlyArray<unknown>>;
type AiGatewayHeaders = NonNullable<AiGatewayUniversalRequest["headers"]>;
type AiGatewayRunOptions = Parameters<CloudflareAiGateway["run"]>[1];
interface AiGatewayFetchOptions {
  readonly provider?: AiGatewayProvider;
  readonly path?: string;
  readonly init?: RequestInit;
}
interface AiGatewayClient {
  readonly run: (data: AiGatewayUniversalRequest | ReadonlyArray<AiGatewayUniversalRequest>, options?: AiGatewayRunOptions) => Effect.Effect<Response, AiGatewayOperationError>;
  readonly getUrl: (provider?: AiGatewayProvider) => Effect.Effect<string, AiGatewayOperationError>;
  readonly fetch: (options: AiGatewayFetchOptions) => Effect.Effect<Response, AiGatewayOperationError>;
  readonly patchLog: (logId: string, data: AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError>;
  readonly getLog: (logId: string) => Effect.Effect<AiGatewayLog, AiGatewayOperationError>;
  readonly unsafeRaw: Effect.Effect<AiGatewayBinding, AiGatewayOperationError>;
  readonly definition: AiGatewayDefinition;
}
declare const AiGatewayServiceTypeId: unique symbol;
/** Nominal service marker for AI Gateway services created with {@link make}. */
interface AiGatewayService<Id extends string> {
  readonly [AiGatewayServiceTypeId]: {
    readonly id: Id;
  };
}
type LayerOptions$17 = {
  readonly binding: string;
  readonly gatewayId: string;
  readonly accountId?: string;
};
interface TagClass$15<Self, Id extends string> extends Context.ServiceClass<Self, Id, AiGatewayClient> {
  readonly id: Id;
  readonly layer: (options: LayerOptions$17) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
}
declare const isAiGatewayBinding: (value: unknown) => value is WorkersAiBinding;
declare const makeClient$11: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
  definition: AiGatewayDefinition;
  run: (data: _$_cloudflare_workers_types0.AIGatewayUniversalRequest | readonly _$_cloudflare_workers_types0.AIGatewayUniversalRequest[], options: {
    gateway?: _$_cloudflare_workers_types0.UniversalGatewayOptions;
    extraHeaders?: object;
    signal?: _$_cloudflare_workers_types0.AbortSignal;
  } | undefined) => Effect.Effect<_$_cloudflare_workers_types0.Response, AiGatewayOperationError, never>;
  getUrl: (provider: string | undefined) => Effect.Effect<string, AiGatewayOperationError, never>;
  fetch: (options: AiGatewayFetchOptions) => Effect.Effect<Response, AiGatewayOperationError, never>;
  patchLog: (logId: string, data: _$_cloudflare_workers_types0.AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError, never>;
  getLog: (logId: string) => Effect.Effect<_$_cloudflare_workers_types0.AiGatewayLog, AiGatewayOperationError, never>;
  unsafeRaw: Effect.Effect<CloudflareAiGateway, never, never>;
};
declare const makeClientFromAi: (definition: AiGatewayDefinition, ai: WorkersAiBinding) => AiGatewayClient;
declare const makeHttpClient: (definition: Omit<AiGatewayDefinition, "binding"> & {
  readonly accountId: string;
  readonly binding?: string;
}, request?: typeof fetch) => AiGatewayClient;
declare const layer$14: <Self>(tag: Context.Service<Self, AiGatewayClient>, definition: AiGatewayDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare const make$15: <Id extends string>(id: Id) => TagClass$15<AiGatewayService<Id>, Id>;
declare const Tag$16: <Self>() => <Id extends string>(id: Id) => TagClass$15<Self, Id>;
declare namespace AnalyticsEngine_d_exports {
  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteBatchOptions, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, LayerOptions$16 as LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag$15 as Tag, TagClass$14 as TagClass, isAnalyticsEngineDataset, layer$13 as layer, make$14 as make, makeClient$10 as makeClient, makeQuery, makeQueryClient, queryConfig, queryFetchLayer, queryFetchLayerConfig, queryLayer, queryLayerConfig, writeLimits };
}
declare const writeLimits: {
  readonly maxBlobs: 20;
  readonly maxDoubles: 20;
  readonly maxIndexes: 1;
  readonly maxBlobBytes: number;
  readonly maxIndexBytes: 96;
  readonly maxDataPointsPerInvocation: 250;
};
declare const queryColumnSchema: Schema.Struct<{
  readonly name: Schema.String;
  readonly type: Schema.String;
}>;
declare const queryRowSchema: Schema.$Record<Schema.String, Schema.Unknown>;
declare const AnalyticsEngineFieldValueSchema: Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.instanceOf<ArrayBuffer, unknown>]>>;
declare const AnalyticsEngineDataPointSchema: Schema.Struct<{
  readonly indexes: Schema.optional<Schema.$Array<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.instanceOf<ArrayBuffer, unknown>]>>>>;
  readonly doubles: Schema.optional<Schema.$Array<Schema.Finite>>;
  readonly blobs: Schema.optional<Schema.$Array<Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.instanceOf<ArrayBuffer, unknown>]>>>>;
}>;
declare const AnalyticsEngineOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "AnalyticsEngineOperationError";
} & Readonly<A>;
/** Error raised when an Analytics Engine operation fails. */
declare class AnalyticsEngineOperationError extends AnalyticsEngineOperationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly cause: unknown;
}> {}
interface AnalyticsEngineWriteViolation {
  readonly path: string;
  readonly message: string;
  readonly limit?: number;
  readonly actual?: number;
}
declare const AnalyticsEngineWriteValidationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "AnalyticsEngineWriteValidationError";
} & Readonly<A>;
/** Error raised when an Analytics Engine write input violates Cloudflare limits. */
declare class AnalyticsEngineWriteValidationError extends AnalyticsEngineWriteValidationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly violations: ReadonlyArray<AnalyticsEngineWriteViolation>;
  readonly cause?: unknown;
}> {}
declare const AnalyticsEngineQueryError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "AnalyticsEngineQueryError";
} & Readonly<A>;
/** Error raised when an Analytics Engine SQL API query fails. */
declare class AnalyticsEngineQueryError extends AnalyticsEngineQueryError_base<{
  readonly operation: string;
  readonly accountId: string;
  readonly message: string;
  readonly status?: number;
  readonly body?: string;
  readonly cause?: unknown;
}> {}
/** Typed Analytics Engine dataset binding definition. */
interface AnalyticsEngineDefinition {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
}
type AnalyticsEngineBinding = CloudflareAnalyticsEngineDataset;
type AnalyticsEngineDataPoint = CloudflareAnalyticsEngineDataPoint;
type AnalyticsEngineFieldValue = ArrayBuffer | string | null;
type AnalyticsEngineWriteError = AnalyticsEngineOperationError | AnalyticsEngineWriteValidationError;
type AnalyticsEngineInvalidWritePolicy = "error" | "drop";
type AnalyticsEngineQueryColumn = Schema.Schema.Type<typeof queryColumnSchema>;
type AnalyticsEngineQueryRow = Schema.Schema.Type<typeof queryRowSchema>;
interface AnalyticsEngineWriteOptions {
  /**
   * Controls invalid write behavior. The default is `"error"`, which fails with
   * `AnalyticsEngineWriteValidationError`. `"drop"` skips invalid points.
   */
  readonly onInvalid?: AnalyticsEngineInvalidWritePolicy;
}
interface AnalyticsEngineWriteBatchOptions extends AnalyticsEngineWriteOptions {
  /**
   * Maximum points per native batch call. Values are clamped to Cloudflare's
   * per-invocation limit.
   */
  readonly batchSize?: number;
}
type AnalyticsEngineWritePolicy = AnalyticsEngineWriteBatchOptions;
interface AnalyticsEngineQueryResult<Row = AnalyticsEngineQueryRow> {
  readonly meta: ReadonlyArray<AnalyticsEngineQueryColumn>;
  readonly data: ReadonlyArray<Row>;
  readonly rows: number;
}
interface AnalyticsEngineQueryDefinition {
  /** Cloudflare account id that owns the Analytics Engine datasets. */
  readonly accountId: string;
  /** API token with Account Analytics Read permission. */
  readonly apiToken: Redacted.Redacted<string>;
  /** Base Cloudflare API URL. Defaults to `https://api.cloudflare.com/client/v4`. */
  readonly apiBaseUrl?: string | URL;
}
interface AnalyticsEngineQueryOptions {
  /** Additional request headers. Authorization is always derived from `apiToken`. */
  readonly headers?: Headers$1.Input;
}
interface AnalyticsEngineClient {
  readonly writeDataPoint: (dataPoint?: AnalyticsEngineDataPoint, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
  readonly write: (dataPoint?: AnalyticsEngineDataPoint, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
  readonly writeDataPoints: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>, options?: AnalyticsEngineWriteBatchOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
  readonly writeBatch: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>, options?: AnalyticsEngineWriteBatchOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
  readonly unsafeRaw: Effect.Effect<AnalyticsEngineBinding>;
  readonly definition: AnalyticsEngineDefinition;
}
interface AnalyticsEngineQueryClient {
  readonly query: (sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<AnalyticsEngineQueryResult, AnalyticsEngineQueryError | Schema.SchemaError>;
  readonly queryResult: <Row>(row: Schema.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<AnalyticsEngineQueryResult<Row>, AnalyticsEngineQueryError | Schema.SchemaError>;
  readonly queryRows: <Row>(row: Schema.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<ReadonlyArray<Row>, AnalyticsEngineQueryError | Schema.SchemaError>;
  readonly queryOne: <Row>(row: Schema.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<Option.Option<Row>, AnalyticsEngineQueryError | Schema.SchemaError>;
  readonly queryText: (sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<string, AnalyticsEngineQueryError>;
  readonly raw: (sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<HttpClientResponse.HttpClientResponse, AnalyticsEngineQueryError>;
  readonly definition: AnalyticsEngineQueryDefinition;
}
declare const AnalyticsEngineServiceTypeId: unique symbol;
declare const AnalyticsEngineQueryServiceTypeId: unique symbol;
/** Nominal service marker for Analytics Engine services created with {@link make}. */
interface AnalyticsEngineService<Id extends string> {
  readonly [AnalyticsEngineServiceTypeId]: {
    readonly id: Id;
  };
}
/** Nominal service marker for Analytics Engine query services created with {@link makeQuery}. */
interface AnalyticsEngineQueryService<Id extends string> {
  readonly [AnalyticsEngineQueryServiceTypeId]: {
    readonly id: Id;
  };
}
type LayerOptions$16 = {
  readonly binding: string;
  readonly write?: AnalyticsEngineWritePolicy;
};
type QueryConfigOptions = {
  readonly accountId?: Config.Config<string>;
  readonly apiToken?: Config.Config<Redacted.Redacted<string>>;
  readonly apiBaseUrl?: Config.Config<string>;
};
interface TagClass$14<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineClient> {
  readonly id: Id;
  readonly layer: (options: LayerOptions$16) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
}
interface QueryTagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, AnalyticsEngineQueryClient> {
  readonly id: Id;
  readonly layer: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, HttpClient.HttpClient>;
  readonly fetchLayer: (definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self>;
  readonly layerConfig: (config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, HttpClient.HttpClient>;
  readonly fetchLayerConfig: (config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError>;
}
declare const makeQueryClient: (definition: AnalyticsEngineQueryDefinition) => Effect.Effect<AnalyticsEngineQueryClient, never, HttpClient.HttpClient>;
declare const isAnalyticsEngineDataset: (value: unknown) => value is AnalyticsEngineBinding;
declare const makeClient$10: (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) => (dataset: AnalyticsEngineBinding) => AnalyticsEngineClient;
declare const queryConfig: (options?: QueryConfigOptions) => Config.Config<{
  accountId: string;
  apiToken: Redacted.Redacted<string>;
  apiBaseUrl: string;
}>;
declare const queryLayer: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, HttpClient.HttpClient>;
declare const queryFetchLayer: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, definition: AnalyticsEngineQueryDefinition) => Layer.Layer<Self, never, never>;
declare const queryLayerConfig: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, HttpClient.HttpClient>;
declare const queryFetchLayerConfig: <Self>(tag: Context.Service<Self, AnalyticsEngineQueryClient>, config?: Config.Config<AnalyticsEngineQueryDefinition>) => Layer.Layer<Self, Config.ConfigError, never>;
declare const layer$13: <Self>(tag: Context.Service<Self, AnalyticsEngineClient>, definition: LayerOptions$16) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare const make$14: <Id extends string>(id: Id) => TagClass$14<AnalyticsEngineService<Id>, Id>;
declare const makeQuery: <Id extends string>(id: Id) => QueryTagClass<AnalyticsEngineQueryService<Id>, Id>;
declare const Tag$15: <Self>() => <Id extends string>(id: Id) => TagClass$14<Self, Id>;
declare const QueryTag: <Self>() => <Id extends string>(id: Id) => QueryTagClass<Self, Id>;
declare namespace BrowserRendering_d_exports {
  export { BrowserRenderingBinding, BrowserRenderingBrowserClient, BrowserRenderingBrowserLike, BrowserRenderingClient, BrowserRenderingConnect, BrowserRenderingDefinition, BrowserRenderingLaunch, BrowserRenderingOperationError, BrowserRenderingPageClient, BrowserRenderingPageLike, BrowserRenderingService, LayerOptions$15 as LayerOptions, Tag$14 as Tag, TagClass$13 as TagClass, isBrowserRenderingBinding, layer$12 as layer, make$13 as make, makeClient$9 as makeClient };
}
declare const BrowserRenderingOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "BrowserRenderingOperationError";
} & Readonly<A>;
/** Error raised when a Browser Rendering operation fails. */
declare class BrowserRenderingOperationError extends BrowserRenderingOperationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly cause: unknown;
}> {}
/** Typed Browser Rendering binding definition. */
interface BrowserRenderingDefinition {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
}
type BrowserRenderingBinding = object;
type BrowserRenderingLaunch<RawBinding, Browser, LaunchOptions = unknown> = (binding: RawBinding, options?: LaunchOptions) => Promise<Browser>;
type BrowserRenderingConnect<RawBinding, Browser, ConnectOptions = unknown> = (binding: RawBinding, options?: ConnectOptions) => Promise<Browser>;
interface BrowserRenderingBrowserLike<Page = BrowserRenderingPageLike> {
  readonly newPage: () => Promise<Page>;
  readonly close?: () => Promise<void>;
  readonly disconnect?: () => void;
  readonly version?: () => Promise<string>;
}
interface BrowserRenderingPageLike {
  readonly goto?: (url: string, options?: unknown) => Promise<unknown>;
  readonly setContent?: (html: string, options?: unknown) => Promise<void>;
  readonly content?: () => Promise<string>;
  readonly screenshot?: (options?: unknown) => Promise<Uint8Array | string>;
  readonly pdf?: (options?: unknown) => Promise<Uint8Array>;
  readonly evaluate?: (pageFunction: unknown, ...args: ReadonlyArray<unknown>) => Promise<unknown>;
  readonly close?: (options?: unknown) => Promise<void>;
}
interface BrowserRenderingPageClient<Page extends BrowserRenderingPageLike> {
  readonly raw: Page;
  readonly goto: (url: string, options?: Parameters<NonNullable<Page["goto"]>>[1]) => Effect.Effect<Awaited<ReturnType<NonNullable<Page["goto"]>>>, BrowserRenderingOperationError>;
  readonly setContent: (html: string, options?: Parameters<NonNullable<Page["setContent"]>>[1]) => Effect.Effect<void, BrowserRenderingOperationError>;
  readonly content: Effect.Effect<string, BrowserRenderingOperationError>;
  readonly screenshot: <A = Uint8Array | string>(options?: Parameters<NonNullable<Page["screenshot"]>>[0]) => Effect.Effect<A, BrowserRenderingOperationError>;
  readonly pdf: <A = Uint8Array>(options?: Parameters<NonNullable<Page["pdf"]>>[0]) => Effect.Effect<A, BrowserRenderingOperationError>;
  readonly evaluate: <A = unknown>(pageFunction: Parameters<NonNullable<Page["evaluate"]>>[0], ...args: ReadonlyArray<unknown>) => Effect.Effect<A, BrowserRenderingOperationError>;
  readonly close: (options?: Parameters<NonNullable<Page["close"]>>[0]) => Effect.Effect<void, BrowserRenderingOperationError>;
}
interface BrowserRenderingBrowserClient<Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike> {
  readonly raw: Browser;
  readonly newPage: Effect.Effect<BrowserRenderingPageClient<Page>, BrowserRenderingOperationError>;
  readonly version: Effect.Effect<string, BrowserRenderingOperationError>;
  readonly close: Effect.Effect<void, BrowserRenderingOperationError>;
  readonly disconnect: Effect.Effect<void, BrowserRenderingOperationError>;
}
interface BrowserRenderingClient<RawBinding extends BrowserRenderingBinding = BrowserRenderingBinding> {
  readonly launchWith: <Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike = BrowserRenderingPageLike, LaunchOptions = unknown>(launch: BrowserRenderingLaunch<RawBinding, Browser, LaunchOptions>, options?: LaunchOptions) => Effect.Effect<BrowserRenderingBrowserClient<Browser, Page>, BrowserRenderingOperationError>;
  readonly connectWith: <Browser extends BrowserRenderingBrowserLike<Page>, Page extends BrowserRenderingPageLike = BrowserRenderingPageLike, ConnectOptions = unknown>(connect: BrowserRenderingConnect<RawBinding, Browser, ConnectOptions>, options?: ConnectOptions) => Effect.Effect<BrowserRenderingBrowserClient<Browser, Page>, BrowserRenderingOperationError>;
  readonly unsafeRaw: Effect.Effect<RawBinding>;
  readonly definition: BrowserRenderingDefinition;
}
declare const BrowserRenderingServiceTypeId: unique symbol;
/** Nominal service marker for Browser Rendering services created with {@link make}. */
interface BrowserRenderingService<Id extends string> {
  readonly [BrowserRenderingServiceTypeId]: {
    readonly id: Id;
  };
}
type LayerOptions$15 = {
  readonly binding: string;
};
interface TagClass$13<Self, Id extends string> extends Context.ServiceClass<Self, Id, BrowserRenderingClient> {
  readonly id: Id;
  readonly layer: (options: LayerOptions$15) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
}
declare const isBrowserRenderingBinding: (value: unknown) => value is BrowserRenderingBinding;
declare const makeClient$9: <RawBinding extends BrowserRenderingBinding = BrowserRenderingBinding>(definition: BrowserRenderingDefinition) => (binding: RawBinding) => BrowserRenderingClient<RawBinding>;
declare const layer$12: <Self>(tag: Context.Service<Self, BrowserRenderingClient>, definition: BrowserRenderingDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare const make$13: <Id extends string>(id: Id) => TagClass$13<BrowserRenderingService<Id>, Id>;
declare const Tag$14: <Self>() => <Id extends string>(id: Id) => TagClass$13<Self, Id>;
declare namespace DurableObjectStorage_d_exports {
  export { DurableObjectStorage, DurableObjectTransaction, SchemaBackedSyncKvStorage, SqlCursor, SqlStorage, SqlStorageValue, StorageOperationError, SyncKvDefinition, SyncKvStorage, fromDurableObjectStorage };
}
/** Supported primitive value types for Durable Object SQL APIs. */
type SqlStorageValue = globalThis.SqlStorageValue;
declare const StorageOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "StorageOperationError";
} & Readonly<A>;
/** Error type used when a storage operation throws or rejects. */
declare class StorageOperationError extends StorageOperationError_base<{
  readonly operation: string;
  readonly cause: unknown;
}> {}
type StorageEffect<A> = Effect.Effect<A, StorageOperationError>;
/**
 * Effect wrapper for Cloudflare SQL cursor operations.
 */
interface SqlCursor<T extends Record<string, SqlStorageValue>> {
  next(): StorageEffect<{
    done?: false;
    value: T;
  } | {
    done: true;
    value?: never;
  }>;
  toArray(): StorageEffect<Array<T>>;
  one(): StorageEffect<T>;
  raw<U extends Array<SqlStorageValue>>(): StorageEffect<IterableIterator<U>>;
  readonly columnNames: Array<string>;
  readonly rowsRead: StorageEffect<number>;
  readonly rowsWritten: StorageEffect<number>;
}
/**
 * Effect wrapper for Durable Object SQLite APIs.
 */
interface SqlStorage {
  /** Executes a SQL statement and returns a typed cursor. */
  exec<T extends Record<string, SqlStorageValue>>(query: string, ...bindings: Array<SqlStorageValue>): StorageEffect<SqlCursor<T>>;
  readonly databaseSize: number;
}
/**
 * Schema pair used by `SyncKvStorage.schema(...)`.
 */
interface SyncKvDefinition<Key, Value, EncodedValue> {
  readonly key: Schema.Codec<Key, string>;
  readonly value: Schema.Codec<Value, EncodedValue>;
}
/**
 * Sync KV wrapper that transparently encodes keys/values through Effect Schema.
 */
interface SchemaBackedSyncKvStorage<Key, Value> {
  get(key: Key): Effect.Effect<Option.Option<Value>, unknown>;
  put(key: Key, value: Value): Effect.Effect<void, unknown>;
  delete(key: Key): Effect.Effect<boolean, unknown>;
  list(options?: globalThis.SyncKvListOptions): Effect.Effect<Array<[Key, Value]>, unknown>;
}
/**
 * Effect wrapper for synchronous KV attached to Durable Object SQLite storage.
 */
interface SyncKvStorage {
  get<T = unknown>(key: string): StorageEffect<T | undefined>;
  put<T>(key: string, value: T): StorageEffect<void>;
  delete(key: string): StorageEffect<boolean>;
  list<T = unknown>(options?: globalThis.SyncKvListOptions): StorageEffect<Array<[string, T]>>;
  schema<Key, Value, EncodedValue>(definition: SyncKvDefinition<Key, Value, EncodedValue>): SchemaBackedSyncKvStorage<Key, Value>;
}
/**
 * Effect wrapper around Cloudflare transaction callbacks.
 */
interface DurableObjectTransaction {
  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
  get<T = unknown>(keys: Array<string>, options?: globalThis.DurableObjectGetOptions): StorageEffect<Map<string, T>>;
  list<T = unknown>(options?: globalThis.DurableObjectListOptions): StorageEffect<Map<string, T>>;
  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
  put<T>(entries: Record<string, T>, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
  delete(keys: Array<string>, options?: globalThis.DurableObjectPutOptions): StorageEffect<number>;
  rollback(): StorageEffect<void>;
  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
}
/**
 * Effect wrapper around Cloudflare Durable Object storage.
 *
 * @example
 * ```ts
 * const program = Effect.gen(function* () {
 *   const state = yield* DurableObjectState;
 *   yield* state.storage.put("counter", 1);
 *   const value = yield* state.storage.get<number>("counter");
 *   return value;
 * });
 * ```
 */
interface DurableObjectStorage {
  get<T = unknown>(key: string, options?: globalThis.DurableObjectGetOptions): StorageEffect<T | undefined>;
  put<T>(key: string, value: T, options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
  delete(key: string, options?: globalThis.DurableObjectPutOptions): StorageEffect<boolean>;
  /**
   * Deletes all stored data. On compatibility dates before 2026-02-24, Cloudflare
   * documents that active alarms must be deleted separately with `deleteAlarm()`.
   */
  deleteAll(options?: globalThis.DurableObjectPutOptions): StorageEffect<void>;
  getAlarm(options?: globalThis.DurableObjectGetAlarmOptions): StorageEffect<number | null>;
  setAlarm(scheduledTime: number | Date, options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
  deleteAlarm(options?: globalThis.DurableObjectSetAlarmOptions): StorageEffect<void>;
  /**
   * SQLite-backed Durable Object storage only.
   *
   * The callback Effect must complete synchronously. If it requires asynchronous
   * work, use `transaction` instead so Cloudflare can run the async transaction
   * callback under the platform's transaction contract.
   */
  transactionSync<A, E, R>(closure: () => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
  /**
   * Runs an async transaction and exposes a typed transaction wrapper.
   */
  transaction<A, E, R>(closure: (txn: DurableObjectTransaction) => Effect.Effect<A, E, R>): Effect.Effect<A, E | StorageOperationError, R>;
  /** Flushes pending writes to disk. */
  sync(): StorageEffect<void>;
  /** SQLite-backed Durable Object storage point-in-time recovery API only. */
  getCurrentBookmark(): StorageEffect<string>;
  /** SQLite-backed Durable Object storage point-in-time recovery API only. */
  onNextSessionRestoreBookmark(bookmark: string): StorageEffect<string>;
  readonly sql: SqlStorage;
  readonly kv: SyncKvStorage;
}
/**
 * Wraps native Cloudflare storage APIs as Effect-returning helpers.
 */
declare const fromDurableObjectStorage: (storage: globalThis.DurableObjectStorage) => DurableObjectStorage;
declare namespace DurableObjectWebSocket_d_exports {
  export { AcceptUpgradeOptions, AcceptedUpgrade, AttachmentInvalidPolicy, AttachmentRehydrateOptions, DurableWebSocket, DurableWebSocketAttachment, DurableWebSocketAttachmentError, DurableWebSocketCloseError, DurableWebSocketHandlers, DurableWebSocketSendData, DurableWebSocketSendError, RehydratedDurableWebSocket, acceptUpgrade, attachment, fromWebSocket, handlers };
}
/** Data supported by Cloudflare websocket `send`. */
type DurableWebSocketSendData = string | ArrayBuffer | ArrayBufferView;
declare const DurableWebSocketSendError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "DurableWebSocketSendError";
} & Readonly<A>;
/** Error raised when sending on a Durable Object websocket fails. */
declare class DurableWebSocketSendError extends DurableWebSocketSendError_base<{
  readonly cause: unknown;
}> {}
declare const DurableWebSocketCloseError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "DurableWebSocketCloseError";
} & Readonly<A>;
/** Error raised when closing a Durable Object websocket fails. */
declare class DurableWebSocketCloseError extends DurableWebSocketCloseError_base<{
  readonly cause: unknown;
}> {}
declare const DurableWebSocketAttachmentError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "DurableWebSocketAttachmentError";
} & Readonly<A>;
/** Error raised when serializing or deserializing a websocket attachment fails. */
declare class DurableWebSocketAttachmentError extends DurableWebSocketAttachmentError_base<{
  readonly operation: "serialize" | "deserialize";
  readonly cause: unknown;
}> {}
/** Effect-native wrapper around a hibernatable Durable Object websocket. */
interface DurableWebSocket<Attachment = unknown> {
  /** Underlying Cloudflare websocket. */
  readonly raw: WebSocket;
  /** Sends a message through the socket. */
  send(data: DurableWebSocketSendData): Effect.Effect<void, DurableWebSocketSendError>;
  /** Closes the socket. */
  close(code?: number, reason?: string): Effect.Effect<void, DurableWebSocketCloseError>;
  /** Serializes hibernation attachment metadata onto the socket. */
  serializeAttachment<A = Attachment>(value: A): Effect.Effect<void, DurableWebSocketAttachmentError>;
  /** Deserializes hibernation attachment metadata from the socket. */
  readonly deserializeAttachment: Effect.Effect<unknown, DurableWebSocketAttachmentError>;
}
/** Wraps a native Cloudflare websocket in the Effect-native Durable Object API. */
declare const fromWebSocket: <Attachment = unknown>(raw: WebSocket) => DurableWebSocket<Attachment>;
/**
 * Options for accepting an incoming websocket request in a Durable Object.
 */
interface AcceptUpgradeOptions<Attachment = unknown> {
  /** Optional websocket tags for Durable Object hibernation filtering. */
  readonly tags?: ReadonlyArray<string> | undefined;
  /** Optional attachment serialized onto the server socket. */
  readonly attachment?: Attachment | undefined;
}
/**
 * Result of a websocket upgrade accepted by {@link acceptUpgrade}.
 */
interface AcceptedUpgrade<Attachment = unknown> {
  readonly client: WebSocket;
  readonly server: DurableWebSocket<Attachment>;
  readonly response: Response;
}
/**
 * Accepts a websocket upgrade and registers the server socket on `DurableObjectState`.
 *
 * @example
 * ```ts
 * const response = yield* DurableObjectWebSocket.acceptUpgrade({
 *   tags: ["room:general"],
 * });
 *
 * return response.response;
 * ```
 */
declare const acceptUpgrade: <Attachment = unknown>(options?: AcceptUpgradeOptions<Attachment>) => Effect.Effect<AcceptedUpgrade<Attachment>, never, DurableObjectState>;
type AttachmentInvalidPolicy = "ignore" | "ignore-and-close" | "fail";
interface AttachmentRehydrateOptions {
  /** Optional Durable Object websocket tag filter. */
  readonly tag?: string | undefined;
  /** Invalid attachment behavior. Defaults to skipping invalid sockets. */
  readonly onInvalid?: AttachmentInvalidPolicy | undefined;
}
interface RehydratedDurableWebSocket<Attachment> {
  readonly socket: DurableWebSocket<Attachment>;
  readonly attachment: Attachment;
}
interface DurableWebSocketAttachment<Attachment, Encoded> {
  serialize(socket: DurableWebSocket<unknown>, value: Attachment): Effect.Effect<void, DurableWebSocketAttachmentError>;
  deserialize(socket: DurableWebSocket<unknown>): Effect.Effect<Option.Option<Attachment>, DurableWebSocketAttachmentError>;
  rehydrate(options?: AttachmentRehydrateOptions): Effect.Effect<Array<RehydratedDurableWebSocket<Attachment>>, DurableWebSocketAttachmentError, DurableObjectState>;
  readonly schema: Schema.Codec<Attachment, Encoded, never, never>;
}
/** Creates typed attachment helpers for accepted and rehydrated sockets. */
declare const attachment: <const AttachmentSchema extends Schema.Codec<any, any, never, never>>(schema: AttachmentSchema) => DurableWebSocketAttachment<Schema.Schema.Type<AttachmentSchema>, Schema.Codec.Encoded<AttachmentSchema>>;
interface DurableWebSocketHandlers<R = never, E = unknown> {
  readonly message?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>;
  readonly close?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>;
  readonly error?: (socket: DurableWebSocket, error: unknown) => Effect.Effect<void, E, R>;
}
/** Maps compact websocket lifecycle handler names to `DurableObject.make` options. */
declare const handlers: <R = never, E = unknown>(options: DurableWebSocketHandlers<R, E>) => {
  webSocketMessage: ((socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, E, R>) | undefined;
  webSocketClose: ((socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, E, R>) | undefined;
  webSocketError: ((socket: DurableWebSocket, error: unknown) => Effect.Effect<void, E, R>) | undefined;
};
declare namespace DurableObjectState_d_exports {
  export { DurableObjectState, DurableObjectStateService, fromDurableObjectState };
}
/**
 * Effect-friendly wrapper around Cloudflare `DurableObjectState`.
 */
interface DurableObjectStateService {
  /** Underlying Cloudflare state instance. */
  readonly raw: globalThis.DurableObjectState;
  /** Durable Object id for the current instance. */
  readonly id: globalThis.DurableObjectId;
  /** Wrapped storage API. */
  readonly storage: DurableObjectStorage;
  /** Registers background work with Cloudflare's lifecycle. */
  waitUntil(promise: Promise<unknown>): Effect.Effect<void>;
  /**
   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate.
   *
   * Cloudflare resets a Durable Object if the callback throws/rejects, or if the
   * callback exceeds the platform timeout (currently documented as 30 seconds).
   * This safe default resolves the callback with the Effect `Exit` for typed
   * Effect failures and resumes that `Exit` afterward, so typed failures remain
   * ordinary Effect failures instead of resetting the Durable Object. Defects
   * and interruptions still reject the callback.
   */
  blockConcurrencyWhile<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
  /**
   * Runs an Effect inside Cloudflare's `blockConcurrencyWhile` gate and lets
   * Effect failures reject the callback.
   *
   * Use this only when Cloudflare's reset-on-throw behavior is intentional. The
   * platform also resets the Durable Object if the callback exceeds the
   * documented timeout (currently 30 seconds).
   */
  blockConcurrencyWhileOrReset<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
  /** Accepts a websocket connection for hibernation-capable Durable Objects. */
  acceptWebSocket(ws: DurableWebSocket, tags?: Array<string>): Effect.Effect<void>;
  /** Lists active sockets, optionally filtered by tag. */
  getWebSockets(tag?: string): Effect.Effect<Array<DurableWebSocket>>;
  /** Configures automatic request/response handling for sockets. */
  setWebSocketAutoResponse(pair?: WebSocketRequestResponsePair): Effect.Effect<void>;
  /** Gets the configured websocket auto-response pair. */
  getWebSocketAutoResponse: Effect.Effect<WebSocketRequestResponsePair | null>;
  /** Timestamp of the last automatic websocket response for a socket. */
  getWebSocketAutoResponseTimestamp(ws: DurableWebSocket): Effect.Effect<Date | null>;
  /** Sets the timeout for hibernatable websocket events. */
  setHibernatableWebSocketEventTimeout(timeoutMs?: number): Effect.Effect<void>;
  /** Gets the timeout for hibernatable websocket events. */
  getHibernatableWebSocketEventTimeout: Effect.Effect<number | null>;
  /** Reads tags attached to a websocket. */
  getTags(ws: DurableWebSocket): Effect.Effect<Array<string>>;
  /**
   * Forcibly resets the Durable Object. Cloudflare logs an uncaught Error using
   * the optional reason, and the method is not available in `wrangler dev` local
   * development according to the Durable Object State docs.
   */
  abort(reason?: string): Effect.Effect<void>;
}
declare const DurableObjectState_base: Context.ServiceClass<DurableObjectState, "effect-cf/DurableObjectState", DurableObjectStateService>;
/**
 * Context tag for accessing the current Durable Object state service.
 */
declare class DurableObjectState extends DurableObjectState_base {}
/**
 * Wraps a native Cloudflare `DurableObjectState` as a {@link DurableObjectStateService}.
 */
declare const fromDurableObjectState: (state: globalThis.DurableObjectState) => DurableObjectStateService;
declare namespace CloudflareOtlp_d_exports {
  export { DurableObjectLayerOptions, LayerOptions$14 as LayerOptions, ResourceOptions, Serialization, Signal, WorkerLayerOptions, durableObjectLayer, layer$11 as layer, layerJson, layerProtobuf, workerLayer };
}
/** Telemetry signal groups supported by the Cloudflare OTLP layers. */
type Signal = "logs" | "traces" | "metrics";
/** OTLP payload serialization used by the Effect OTLP exporters. */
type Serialization = "json" | "protobuf";
/** Resource metadata shared by Worker and Durable Object OTLP layers. */
interface ResourceOptions {
  /** Explicit service name. OTEL resource environment variables take precedence. */
  readonly serviceName?: string;
  /** Explicit service version. OTEL resource environment variables take precedence. */
  readonly serviceVersion?: string;
  /** Additional resource attributes attached to exported telemetry. */
  readonly attributes?: Record<string, unknown>;
}
/** Options shared by all Cloudflare OTLP telemetry layers. */
interface LayerOptions$14 {
  /**
   * Telemetry signals to export. Defaults to logs, traces, and metrics.
   *
   * Each selected signal is still controlled by standard OTEL exporter config,
   * such as `OTEL_TRACES_EXPORTER=otlp`.
   */
  readonly signals?: ReadonlyArray<Signal>;
  /** OTLP payload serialization. Defaults to protobuf. */
  readonly serialization?: Serialization;
  /** Resource metadata forwarded to Effect's OTLP resource resolver. */
  readonly resource?: ResourceOptions;
  /**
   * Explicit headers for every selected signal.
   *
   * When omitted, Effect reads `OTEL_EXPORTER_OTLP_HEADERS` and the
   * signal-specific `OTEL_EXPORTER_OTLP_*_HEADERS` variables.
   */
  readonly headers?: Headers$1.Input;
  /** Exclude log records emitted for spans when exporting logs. */
  readonly loggerExcludeLogSpans?: boolean;
  /** Merge the OTLP logger with existing loggers instead of replacing them. */
  readonly loggerMergeWithExisting?: boolean;
  /** Custom trace context lookup used by the Effect OTLP tracer. */
  readonly tracerContext?: <X>(primitive: Tracer.EffectPrimitive<X>, span: Tracer.AnySpan) => X;
}
/** Resource metadata specific to Cloudflare Workers. */
interface WorkerLayerOptions extends LayerOptions$14 {
  /** Cloudflare Worker name to attach as `cloudflare.worker.name`. */
  readonly workerName?: string;
}
/** Resource metadata specific to Cloudflare Durable Objects. */
interface DurableObjectLayerOptions extends LayerOptions$14 {
  /** Durable Object class name to attach as `cloudflare.durable_object.class`. */
  readonly className?: string;
  /**
   * Include the Durable Object id as `cloudflare.durable_object.id`.
   *
   * This is disabled by default because object ids can be high-cardinality.
   */
  readonly includeObjectId?: boolean;
}
/**
 * Base OTLP telemetry layer for Cloudflare-compatible runtimes.
 *
 * Standard OpenTelemetry environment variables are resolved by Effect's OTLP
 * layers. In Cloudflare Workers and Durable Objects, the current `env` object is
 * installed as the primary `ConfigProvider`; outside Cloudflare, the ambient
 * Effect `ConfigProvider` remains the fallback.
 */
declare const layer$11: (options?: LayerOptions$14) => Layer.Layer<never, never, never>;
/** Base OTLP telemetry layer forced to JSON serialization. */
declare const layerJson: (options?: Omit<LayerOptions$14, "serialization">) => Layer.Layer<never, never, never>;
/** Base OTLP telemetry layer forced to protobuf serialization. */
declare const layerProtobuf: (options?: Omit<LayerOptions$14, "serialization">) => Layer.Layer<never, never, never>;
/**
 * OTLP layer with Cloudflare Worker resource attributes.
 *
 * Provide this layer at runtime scope for long-lived metrics aggregation, or at
 * handler scope when traces/logs should flush as the Cloudflare event finishes.
 */
declare const workerLayer: (options?: WorkerLayerOptions) => Layer.Layer<never, never, never>;
/**
 * OTLP layer with Cloudflare Durable Object resource attributes.
 *
 * The layer reads {@link DurableObjectState} so it can optionally include the
 * Durable Object id. Prefer leaving `includeObjectId` disabled unless the
 * backend can tolerate high-cardinality resource attributes.
 */
declare const durableObjectLayer: (options?: DurableObjectLayerOptions) => Layer.Layer<never, never, DurableObjectState>;
declare namespace D1_d_exports {
  export { D1Definition, D1Service, D1SqlLayerOptions, Service$1 as Service, make$12 as make };
}
/** Typed D1 binding definition. */
interface D1Definition {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
}
/** Options forwarded to `@effect/sql-d1` when building a SQL client layer. */
type D1SqlLayerOptions = Omit<D1Client.D1ClientConfig, "db">;
declare const D1ServiceTypeId: unique symbol;
/** Nominal service marker for D1 services created with {@link make}. */
interface D1Service<Id extends string> {
  readonly [D1ServiceTypeId]: {
    readonly id: Id;
  };
}
/**
 * Creates a typed D1 service tag plus Effect helpers.
 */
declare const make$12: <Id extends string>(id: Id, definition: D1Definition) => BindingService<D1Service<Id>, Id, D1Database> & {
  "effect-cf/D1": "effect-cf/D1";
  definition: D1Definition;
  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | _$effect_unstable_sql_SqlClient0.SqlClient, BindingNotFoundError | BindingValidationError | _$effect_Config0.ConfigError, WorkerEnvironment>;
};
/**
 * Builds a D1 service around a Cloudflare D1 database binding.
 *
 * The returned service exposes the raw `D1Database` binding and `sqlLayer(...)`
 * for providing `effect/unstable/sql` via `@effect/sql-d1`.
 *
 * @example
 * ```ts
 * class TodoDatabase extends D1.Service<TodoDatabase>()("TodoDatabase", {
 *   binding: "TODO_DB",
 * }) {}
 *
 * const SqlLive = TodoDatabase.sqlLayer();
 * ```
 */
declare const Service$1: <Self>() => <Id extends string>(id: Id, definition: D1Definition) => BindingService<Self, Id, D1Database> & {
  "effect-cf/D1": "effect-cf/D1";
  definition: D1Definition;
  sqlLayer: (options?: D1SqlLayerOptions) => Layer.Layer<D1Client.D1Client | _$effect_unstable_sql_SqlClient0.SqlClient, BindingNotFoundError | BindingValidationError | _$effect_Config0.ConfigError, WorkerEnvironment | Exclude<Exclude<Self, _$effect_Scope0.Scope>, Self>>;
};
declare namespace Rpc_d_exports {
  export { DisposableValue, MethodArgs, MethodKey, MethodReturn, Provider, Result$1 as Result, RpcStub, RpcTarget, Serializable, Stub, Stubable, Stubify, dispose, isDisposable, resolve, scoped };
}
type Stubable = Rpc.Stubable;
type Stub<T extends Stubable> = Rpc.Stub<T>;
type Provider<T extends object, Reserved extends string = never> = Rpc.Provider<T, Reserved>;
type BaseType = void | undefined | null | boolean | number | bigint | string | TypedArray | ArrayBuffer | DataView | Date | Error | RegExp | ReadableStream<Uint8Array> | WritableStream<Uint8Array> | Request | Response | Headers;
type Serializable<T> = BaseType | Map<T extends Map<infer Key, unknown> ? Serializable<Key> : never, T extends Map<unknown, infer Value> ? Serializable<Value> : never> | Set<T extends Set<infer Value> ? Serializable<Value> : never> | ReadonlyArray<T extends ReadonlyArray<infer Value> ? Serializable<Value> : never> | { [Key in keyof T]: Key extends number | string ? Serializable<T[Key]> : never } | Stub<Stubable> | Stubable;
type Stubify<T> = T extends Stubable ? Stub<T> : T extends Map<infer Key, infer Value> ? Map<Stubify<Key>, Stubify<Value>> : T extends Set<infer Value> ? Set<Stubify<Value>> : T extends Array<infer Value> ? Array<Stubify<Value>> : T extends ReadonlyArray<infer Value> ? ReadonlyArray<Stubify<Value>> : T extends BaseType ? T : T extends {
  [key: string | number]: unknown;
} ? { [Key in keyof T]: Stubify<T[Key]> } : T;
type MaybeProvider<T> = T extends object ? Provider<T> : unknown;
type MaybeDisposable<T> = T extends object ? Disposable : unknown;
type Result$1<T> = T extends Stubable ? Promise<Stub<T>> & Provider<T> : T extends Serializable<T> ? Promise<Stubify<T> & MaybeDisposable<T>> & MaybeProvider<T> : never;
type MethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never }[keyof Api];
type MethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => unknown) ? Args : never;
type MethodReturn<Api, Method extends keyof Api> = Api[Method] extends ((...args: Array<any>) => infer Return) ? Return : never;
type DisposableValue = {
  [Symbol.dispose](): void;
};
declare const isDisposable: (value: unknown) => value is DisposableValue;
declare const dispose: (value: unknown) => Effect.Effect<void>;
declare const resolve: <A>(value: A) => Effect.Effect<Awaited<A>, unknown>;
declare const scoped: <A>(value: A) => Effect.Effect<Awaited<A>, unknown, Scope.Scope>;
declare namespace RpcDefinition_d_exports {
  export { Definition$9 as Definition, Method$5 as Method, Methods$4 as Methods, NoReservedMethods$4 as NoReservedMethods, ReservedMethodName$6 as ReservedMethodName, ReservedMethodNameError, RpcArgumentCountError, RpcArgumentDecodeError, RpcArgumentEncodeError, RpcReservedMethodNameError, RpcSuccessDecodeError, RpcSuccessEncodeError, ServiceFreeSchema$4 as ServiceFreeSchema, assertNoReservedMethodNames, assertNoReservedMethods, decodeArgs, decodeSuccess, encodeArgs, encodeSuccess, make$11 as make, method$4 as method, reservedMethodNames };
}
declare const RpcReservedMethodNameError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "RpcReservedMethodNameError";
} & Readonly<A>;
declare class RpcReservedMethodNameError extends RpcReservedMethodNameError_base<{
  readonly definition: string;
  readonly method: string;
}> {}
declare const RpcArgumentCountError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "RpcArgumentCountError";
} & Readonly<A>;
declare class RpcArgumentCountError extends RpcArgumentCountError_base<{
  readonly definition: string;
  readonly method: string;
  readonly expected: number;
  readonly actual: number;
}> {}
declare const RpcArgumentDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "RpcArgumentDecodeError";
} & Readonly<A>;
declare class RpcArgumentDecodeError extends RpcArgumentDecodeError_base<{
  readonly definition: string;
  readonly method: string;
  readonly index: number;
  readonly cause: unknown;
}> {}
declare const RpcArgumentEncodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "RpcArgumentEncodeError";
} & Readonly<A>;
declare class RpcArgumentEncodeError extends RpcArgumentEncodeError_base<{
  readonly definition: string;
  readonly method: string;
  readonly index: number;
  readonly cause: unknown;
}> {}
declare const RpcSuccessDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "RpcSuccessDecodeError";
} & Readonly<A>;
declare class RpcSuccessDecodeError extends RpcSuccessDecodeError_base<{
  readonly definition: string;
  readonly method: string;
  readonly cause: unknown;
}> {}
declare const RpcSuccessEncodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "RpcSuccessEncodeError";
} & Readonly<A>;
declare class RpcSuccessEncodeError extends RpcSuccessEncodeError_base<{
  readonly definition: string;
  readonly method: string;
  readonly cause: unknown;
}> {}
declare const reservedMethodNames: Set<string>;
type ReservedMethodName$6 = "constructor" | "fetch" | "connect" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError" | "then" | "dup" | "dispose" | "serialize" | "deserialize";
type ServiceFreeSchema$4 = Schema.Codec<any, any, never, never>;
interface Method$5<Args extends ReadonlyArray<ServiceFreeSchema$4> = ReadonlyArray<ServiceFreeSchema$4>, Success extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
  readonly args: Args;
  readonly success: Success;
}
declare namespace Method$5 {
  export type Any = Method$5<ReadonlyArray<ServiceFreeSchema$4>, ServiceFreeSchema$4>;
  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$4>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$4, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$4>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$4>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$4, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$4>] ? [Schema.Codec.Encoded<Head>, ...EncodedArgsFromSchemas<Tail>] : Array<Schema.Codec.Encoded<Args[number]>>;
  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
  export type EncodedSuccess<Self extends Any> = Schema.Codec.Encoded<Self["success"]>;
  export {};
}
type Methods$4 = Record<string, Method$5.Any>;
type NoReservedMethods$4<MethodsShape extends Methods$4, Reserved extends string = ReservedMethodName$6> = Extract<keyof MethodsShape, Reserved> extends never ? MethodsShape : never;
interface Definition$9<Id extends string = string, MethodsShape extends Methods$4 = Methods$4> {
  readonly id: Id;
  readonly methods: MethodsShape;
}
declare namespace Definition$9 {
  type Any = Definition$9<string, Methods$4>;
  type ServerApi<Self extends Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$5.Args<Self["methods"][Key]>) => Promise<Method$5.Success<Self["methods"][Key]>> };
  type Api<Self extends Any, Reserved extends string = never> = Provider<ServerApi<Self>, Reserved>;
  type MethodNames<Self extends Any> = Extract<keyof Self["methods"], string>;
}
declare class ReservedMethodNameError extends Error {
  readonly method: string;
  readonly target: string;
  constructor(target: string, method: string);
}
declare const assertNoReservedMethods: (target: string, methods: Record<string, unknown>, reserved: ReadonlySet<string>) => void;
declare function method$4<Success extends ServiceFreeSchema$4>(definition: {
  readonly success: Success;
}): Method$5<readonly [], Success>;
declare function method$4<const Args extends ReadonlyArray<ServiceFreeSchema$4>, Success extends ServiceFreeSchema$4>(definition: {
  readonly args: Args;
  readonly success: Success;
}): Method$5<Args, Success>;
declare const assertNoReservedMethodNames: (definition: Definition$9.Any) => Effect.Effect<void, RpcReservedMethodNameError>;
declare const decodeArgs: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, args: ReadonlyArray<unknown>) => Effect.Effect<Method$5.Args<Self["methods"][MethodName]>, RpcArgumentCountError | RpcArgumentDecodeError>;
declare const encodeArgs: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, args: Method$5.Args<Self["methods"][MethodName]>) => Effect.Effect<Method$5.EncodedArgs<Self["methods"][MethodName]>, RpcArgumentCountError | RpcArgumentEncodeError>;
declare const encodeSuccess: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, value: Method$5.Success<Self["methods"][MethodName]>) => Effect.Effect<Method$5.EncodedSuccess<Self["methods"][MethodName]>, RpcSuccessEncodeError>;
declare const decodeSuccess: <const Self extends Definition$9.Any, MethodName extends Definition$9.MethodNames<Self>>(definition: Self, methodName: MethodName, value: unknown) => Effect.Effect<Method$5.Success<Self["methods"][MethodName]>, RpcSuccessDecodeError>;
declare const make$11: <Id extends string, const MethodsShape extends Methods$4>(id: Id, methods: MethodsShape) => Definition$9<Id, MethodsShape>;
declare namespace QueueBinding_d_exports {
  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer$10 as layer, makeClient$8 as makeClient };
}
type QueueSendOptions = CloudflareQueueSendOptions;
type QueueSendResponse = CloudflareQueueSendResponse;
type QueueSendBatchOptions = CloudflareQueueSendBatchOptions;
type QueueSendBatchResponse = CloudflareQueueSendBatchResponse;
type QueueMetrics = CloudflareQueueMetrics;
type MessageSendRequest<Body> = CloudflareMessageSendRequest<Body>;
type QueueProducer<Body> = Pick<CloudflareQueue<Body>, "send"> & Partial<Pick<CloudflareQueue<Body>, "sendBatch" | "metrics">>;
interface QueueBindingDefinition<Message extends ServiceFreeSchema$4> {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
  /** Codec used to encode messages before sending them to Cloudflare Queues. */
  readonly message: Message;
}
interface QueueBindingClient<Message extends ServiceFreeSchema$4> {
  readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
  readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError>;
  readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
  readonly unsafeRaw: Effect.Effect<CloudflareQueue<Schema.Codec.Encoded<Message>>>;
}
declare const QueueOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "QueueOperationError";
} & Readonly<A>;
declare class QueueOperationError extends QueueOperationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly cause: unknown;
  readonly message: string;
}> {}
declare const isQueue: <Body>(value: unknown) => value is QueueProducer<Body>;
declare const makeClient$8: <Message extends ServiceFreeSchema$4>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<Schema.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
declare const layer$10: <Self, Message extends ServiceFreeSchema$4>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare namespace QueueDefinition_d_exports {
  export { Definition$8 as Definition, Handler$3 as Handler, LayerOptions$13 as LayerOptions, Options$7 as Options, Queue$1 as Queue, Tag$13 as Tag, TagClass$12 as TagClass, implement$7 as implement, make$10 as make };
}
interface Definition$8<Id extends string = string, Message extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
  readonly id: Id;
  readonly message: Message;
}
declare namespace Definition$8 {
  type Any = Definition$8<string, ServiceFreeSchema$4>;
}
type Handler$3<ROut, Self extends Definition$8.Any> = (batch: QueueBatch<Schema.Schema.Type<Self["message"]>>) => Effect.Effect<void, unknown, ExecutionContext | WorkerContext | WorkerEnvironment | Scope.Scope | ROut>;
interface Options$7<ROut, Self extends Definition$8.Any> extends Omit<WorkerOptions<ROut, Record<never, never>>, "queue" | "rpc"> {
  readonly queue: Handler$3<ROut, Self>;
  readonly rpc?: never;
}
type LayerOptions$13 = {
  readonly binding: string;
};
interface TagClass$12<Self, Id extends string, Message extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, Id, QueueBindingClient<Message>> {
  readonly id: Id;
  readonly message: Message;
  readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$7<ROut, Definition$8<Id, Message>>) => WorkerClass<Record<never, never>, ROut>;
  readonly layer: (options: LayerOptions$13) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
  readonly send: (message: Schema.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
  readonly sendBatch: (messages: Iterable<MessageSendRequest<Schema.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | Schema.SchemaError, Self>;
  readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError, Self>;
  readonly unsafeRaw: () => Effect.Effect<globalThis.Queue<Schema.Codec.Encoded<Message>>, never, Self>;
}
declare const make$10: <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
  readonly message: Message;
}) => TagClass$12<Definition$8<Id, Message>, Id, Message>;
declare const Tag$13: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
  readonly message: Message;
}) => TagClass$12<Self, Id, Message>;
declare const Queue$1: <Self>() => <Id extends string, Message extends ServiceFreeSchema$4>(id: Id, definition: {
  readonly message: Message;
}) => TagClass$12<Self, Id, Message>;
declare const implement$7: <ROut, const Self extends Definition$8.Any>(_definition: Self, handler: Handler$3<ROut, Self>) => Handler$3<ROut, Self>;
declare namespace Queue_d_exports {
  export { Definition$7 as Definition, Handler$2 as Handler, LayerOptions$12 as LayerOptions, Options$6 as Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOptions, Tag$12 as Tag, TagClass$11 as TagClass, decodeBatch, fromMessage, fromMessageBatch, implement$6 as implement };
}
interface QueueMessage<Body> {
  readonly raw: globalThis.Message<unknown>;
  readonly id: string;
  readonly timestamp: Date;
  readonly body: Body;
  readonly attempts: number;
  readonly ack: Effect.Effect<void>;
  readonly retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void>;
}
interface QueueBatch<Body> {
  readonly raw: globalThis.MessageBatch<unknown>;
  readonly messages: ReadonlyArray<QueueMessage<Body>>;
  readonly queue: string;
  readonly metadata: globalThis.MessageBatchMetadata;
  readonly ackAll: Effect.Effect<void>;
  readonly retryAll: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void>;
}
declare const QueueMessageDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "QueueMessageDecodeError";
} & Readonly<A>;
declare class QueueMessageDecodeError extends QueueMessageDecodeError_base<{
  readonly queue: string;
  readonly messageId: string;
  readonly index: number;
  readonly cause: unknown;
}> {}
type RuntimeContext$2<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
type QueueHandlerContext<ROut> = RuntimeContext$2<ROut> | Scope.Scope;
type QueueHandler<ROut, Body = unknown> = (batch: QueueBatch<Body>) => Effect.Effect<void, unknown, QueueHandlerContext<ROut>>;
interface QueueOptions<ROut, Body = unknown> {
  readonly queue: QueueHandler<ROut, Body>;
}
declare const fromMessage: <Body>(message: globalThis.Message<unknown>, body: Body) => {
  raw: Message<unknown>;
  id: string;
  timestamp: Date;
  body: Body;
  attempts: number;
  ack: Effect.Effect<void, never, never>;
  retry: (options?: globalThis.QueueRetryOptions) => Effect.Effect<void, never, never>;
};
declare const fromMessageBatch: <Body>(batch: globalThis.MessageBatch<unknown>, messages: ReadonlyArray<QueueMessage<Body>>) => QueueBatch<Body>;
declare const decodeBatch: <Body>(batch: globalThis.MessageBatch<unknown>, decodeBody: (body: unknown) => Effect.Effect<Body, unknown>) => Effect.Effect<QueueBatch<Body>, QueueMessageDecodeError>;
type Definition$7<Id extends string = string, Message extends Definition$8.Any["message"] = Definition$8.Any["message"]> = Definition$8<Id, Message>;
declare namespace Definition$7 {
  type Any = Definition$8.Any;
}
type LayerOptions$12 = LayerOptions$13;
type TagClass$11<Self, Id extends string, Message extends Definition$8.Any["message"]> = TagClass$12<Self, Id, Message>;
declare const Tag$12: <Self>() => <Id extends string, Message extends Definition$8.Any["message"]>(id: Id, definition: {
  readonly message: Message;
}) => TagClass$11<Self, Id, Message>;
declare const implement$6: <ROut, const Self extends Definition$8.Any>(_definition: Self, handler: Handler$3<ROut, Self>) => Handler$3<ROut, Self>;
type Handler$2<ROut, Self extends Definition$8.Any> = Handler$3<ROut, Self>;
type Options$6<ROut, Self extends Definition$8.Any> = Options$7<ROut, Self>;
declare namespace WorkerDefinition_d_exports {
  export { Api$3 as Api, Definition$6 as Definition, HandlerEffect$3 as HandlerEffect, Handlers$3 as Handlers, LayerOptions$11 as LayerOptions, Method$4 as Method, Methods$3 as Methods, NoReservedMethods$3 as NoReservedMethods, Options$5 as Options, ReservedMethodName$5 as ReservedMethodName, ServerApi$4 as ServerApi, ServiceFreeSchema$3 as ServiceFreeSchema, Tag$11 as Tag, TagClass$10 as TagClass, Worker, implement$5 as implement, make$9 as make, method$3 as method };
}
type ServiceFreeSchema$3 = Schema.Codec<any, any, never, never>;
interface Method$4<Args extends ReadonlyArray<ServiceFreeSchema$3> = ReadonlyArray<ServiceFreeSchema$3>, Success extends ServiceFreeSchema$3 = ServiceFreeSchema$3> {
  readonly args: Args;
  readonly success: Success;
}
declare namespace Method$4 {
  export type Any = Method$4<ReadonlyArray<ServiceFreeSchema$3>, ServiceFreeSchema$3>;
  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$3>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$3, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$3>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$3>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$3, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$3>] ? [Schema.Codec.Encoded<Head>, ...EncodedArgsFromSchemas<Tail>] : Array<Schema.Codec.Encoded<Args[number]>>;
  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
  export type EncodedSuccess<Self extends Any> = Schema.Codec.Encoded<Self["success"]>;
  export {};
}
type Methods$3 = Record<string, Method$4.Any>;
/**
 * RPC contract for a Worker service.
 *
 * Create with {@link make} and reuse to type both worker implementations and
 * service bindings in other workers.
 */
interface Definition$6<Id extends string = string, MethodsShape extends Methods$3 = Methods$3> {
  readonly id: Id;
  readonly methods: MethodsShape;
}
declare namespace Definition$6 {
  type Any = Definition$6<string, Methods$3>;
}
type ReservedMethodName$5 = ReservedMethodName$3;
type NoReservedMethods$3<MethodsShape extends Methods$3> = Extract<keyof MethodsShape, ReservedMethodName$5> extends never ? MethodsShape : never;
/**
 * Promise-based client API derived from a {@link Definition}.
 */
type ServerApi$4<Self extends Definition$6.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$4.Args<Self["methods"][Key]>) => Promise<Method$4.Success<Self["methods"][Key]>> };
type Api$3<Self extends Definition$6.Any> = Provider<ServerApi$4<Self>, ReservedMethodName$5>;
/**
 * Effect handlers for each RPC method in a worker definition.
 */
type Handlers$3<ROut, Self extends Definition$6.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$4.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method$4.Success<Self["methods"][Key]>> };
/**
 * Worker constructor options for a specific RPC definition.
 */
interface Options$5<ROut, Self extends Definition$6.Any, REvent = never, EventLayerError = never> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers$3<ROut | REvent, Self>>, "rpc"> {
  readonly rpc: Handlers$3<ROut | REvent, Self>;
}
type LayerOptions$11 = {
  readonly binding: string;
};
type TagClass$10<Self, Id extends string, MethodsShape extends Methods$3> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$3<Definition$6<Id, MethodsShape>>, Definition$6<Id, MethodsShape>> & {
  readonly id: Id;
  readonly methods: MethodsShape;
  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$5<ROut, Definition$6<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers$3<ROut | REvent, Definition$6<Id, MethodsShape>>, ROut | REvent>;
  readonly layer: (options: LayerOptions$11) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
};
/**
 * Defines a single RPC method schema in a worker definition.
 */
declare const method$3: {
  <Success extends ServiceFreeSchema$3>(definition: {
    readonly success: Success;
  }): Method$4<readonly [], Success>;
  <const Args extends readonly ServiceFreeSchema$3[], Success extends ServiceFreeSchema$3>(definition: {
    readonly args: Args;
    readonly success: Success;
  }): Method$4<Args, Success>;
};
declare const make$9: <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$10<Definition$6<Id, MethodsShape>, Id, MethodsShape>;
declare const Tag$11: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$10<Self, Id, MethodsShape>;
declare const Worker: <Self>() => <Id extends string, const MethodsShape extends Methods$3>(id: Id, methods: MethodsShape & NoReservedMethods$3<MethodsShape>) => TagClass$10<Self, Id, MethodsShape>;
/**
 * Helper for implementing handlers with the exact method shape of a definition.
 */
declare const implement$5: <ROut, const Self extends Definition$6.Any>(_definition: Self, handlers: Handlers$3<ROut, Self>) => Handlers$3<ROut, Self>;
/**
 * Convenience alias for a single worker RPC handler Effect.
 */
type HandlerEffect$3<ROut, Self extends Definition$6.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$4.Success<Self["methods"][Key]>>;
//#endregion
//#region src/internal/RpcInvocation.d.ts
type AnyArgs = Array<any>;
type AsyncMethodKey<Api> = { [Key in keyof Api]-?: Key extends string ? Api[Key] extends ((...args: AnyArgs) => Promise<unknown>) ? Key : never : never }[keyof Api];
type AsyncMethodArgs<Api, Method extends keyof Api> = Api[Method] extends ((...args: infer Args) => Promise<unknown>) ? Args : never;
type AsyncMethodSuccess<Api, Method extends keyof Api> = Api[Method] extends ((...args: AnyArgs) => Promise<infer A>) ? A : never;
type AsyncMethodCloudflareReturn<Api, Method extends keyof Api> = Result$1<AsyncMethodSuccess<Api, Method>>;
declare namespace ServiceBinding_d_exports {
  export { Service, ServiceBindingClient, ServiceBindingDefinition, ServiceBindingEffectClient, ServiceBindingFetchError, ServiceBindingRpcError, ServiceBindingStaticClient, ServiceFetcher, isServiceBindingClient, layer$9 as layer, makeClient$7 as makeClient, makeDirectMethods$1 as makeDirectMethods };
}
declare const TypeId$1: "effect-cf/ServiceBinding";
/**
 * Minimum shape for a Cloudflare service binding.
 */
interface ServiceFetcher {
  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
}
type RpcClient$1<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never]: Api[Key] };
type ReservedMethodName$4 = ReservedMethodName$5 | "fetch";
/**
 * Native Cloudflare service object including optional RPC methods.
 */
type ServiceBindingClient<Api extends object> = ServiceFetcher & RpcClient$1<Provider<Api, ReservedMethodName$4>>;
type ApiFromDefinition<Definition> = Definition extends Definition$6.Any ? ServerApi$4<Definition> : never;
type ApiOrDefinition<Api extends object, Definition> = [Api] extends [never] ? ApiFromDefinition<Definition> : Api;
/**
 * Binding metadata used to create an Effect service from a Worker binding.
 */
interface ServiceBindingDefinition<Definition extends Definition$6.Any | undefined = undefined> {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
  /** Optional RPC schema used for argument/result encoding. */
  readonly definition?: Definition;
}
declare const ServiceBindingFetchError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "ServiceBindingFetchError";
} & Readonly<A>;
/**
 * Failure raised when calling `fetch` on a service binding.
 */
declare class ServiceBindingFetchError extends ServiceBindingFetchError_base<{
  readonly binding: string;
  readonly cause: unknown;
}> {}
declare const ServiceBindingRpcError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "ServiceBindingRpcError";
} & Readonly<A>;
/**
 * Failure raised when invoking an RPC method on a service binding.
 */
declare class ServiceBindingRpcError extends ServiceBindingRpcError_base<{
  readonly binding: string;
  readonly method: string;
  readonly cause: unknown;
}> {}
type ServiceMethodKey<Api> = AsyncMethodKey<Api>;
type ServiceMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Method>;
type ServiceMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
type ServiceMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
type ServiceCall<R, Api> = <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
type DefinitionDirectMethods<R, Definition extends Definition$6.Any> = { readonly [Method in Definition$9.MethodNames<Definition>]: (...args: Method$5.Args<Definition["methods"][Method]>) => Effect.Effect<Method$5.Success<Definition["methods"][Method]>, ServiceBindingRpcError, R> };
type DirectMethods$1<R, Definition> = Definition extends Definition$6.Any ? DefinitionDirectMethods<R, Definition> : {};
type ServiceBindingEffectClient<Api extends object, Definition extends Definition$6.Any | undefined = undefined> = DirectMethods$1<never, Definition> & {
  /**
   * Forwards an HTTP request to the bound Worker service.
   *
   * Use this when the service binding is acting as an HTTP origin rather than a
   * Cloudflare RPC target.
   *
   * @example
   * ```ts
   * import { Effect } from "effect";
   *
   * const program = Effect.gen(function* () {
   *   const api = yield* ApiWorker;
   *   return yield* api.fetch(new Request("https://internal.example/users"));
   * });
   * ```
   */
  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError>;
  /**
   * Invokes a Worker RPC method and returns Cloudflare's raw RPC result.
   *
   * This preserves Cloudflare RPC behavior such as promise-like pipelining and
   * transferable / disposable result objects. It does not resolve the returned
   * promise-like value and it does not decode definition-backed success schemas.
   *
   * Most application code should use {@link call} instead.
   *
   * @example
   * ```ts
   * import { Effect } from "effect";
   *
   * const program = Effect.gen(function* () {
   *   const counter = yield* CounterService;
   *
   *   const result = yield* counter.rpc("increment", 41);
   *   const value = yield* Effect.promise(() => result);
   *
   *   return value;
   * });
   * ```
   */
  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError>;
  /**
   * Invokes a Worker RPC method, resolves Cloudflare's RPC result, and decodes
   * the success value when the binding was created from a definition.
   *
   * This is the normal choice when application code wants the final typed value.
   *
   * @example
   * ```ts
   * import { Effect } from "effect";
   *
   * const program = Effect.gen(function* () {
   *   const counter = yield* CounterService;
   *   const value = yield* counter.call("increment", 41);
   *
   *   return value;
   * });
   * ```
   */
  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError>;
  /**
   * Invokes a Worker RPC method in the current `Scope`, resolves Cloudflare's RPC
   * result, decodes definition-backed success values, and disposes the resolved
   * result when the scope closes if it implements `Symbol.dispose`.
   *
   * Use this for RPC methods that return Cloudflare RPC resources or other
   * disposable objects whose lifetime should be tied to an Effect scope.
   *
   * @example
   * ```ts
   * import { Effect } from "effect";
   *
   * const program = Effect.scoped(
   *   Effect.gen(function* () {
   *     const files = yield* FileService;
   *     const handle = yield* files.scopedCall("open", "report.csv");
   *
   *     return yield* handle.read();
   *   }),
   * );
   * ```
   */
  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
};
type ServiceBindingStaticClient<R, Api extends object, Definition extends Definition$6.Any | undefined = undefined> = DirectMethods$1<R, Definition> & {
  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, ServiceBindingFetchError, R>;
  readonly rpc: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodCloudflareReturn<Api, Method>, ServiceBindingRpcError, R>;
  readonly call: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<ServiceMethodSuccess<Api, Method>, ServiceBindingRpcError, R>;
  readonly scopedCall: <Method extends ServiceMethodKey<Api>>(method: Method, ...args: ServiceMethodArgs<Api, Method>) => Effect.Effect<Awaited<ServiceMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
};
declare const isServiceBindingClient: <Api extends object>(value: unknown) => value is ServiceBindingClient<Api>;
declare const makeClient$7: <Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(definition: ServiceBindingDefinition<Definition>) => ((service: ServiceBindingClient<Api>) => ServiceBindingEffectClient<Api, Definition>);
declare const layer$9: <Self, Api extends object, const Definition extends Definition$6.Any | undefined = undefined>(tag: Context.Service<Self, ServiceBindingEffectClient<Api, Definition>>, definition: ServiceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
/**
 * Creates a typed Effect service for a Worker service binding.
 *
 * Returned value includes:
 * - a Context tag for dependency injection
 * - `fetch(...)` for raw HTTP forwarding
 * - `rpc(...)` for raw Cloudflare RPC results
 * - `call(...)` for resolved and decoded RPC results
 * - `scopedCall(...)` for scoped and decoded disposable RPC results
 * - direct RPC methods when `definition` is provided
 *
 * @example
 * ```ts
 * const Counter = WorkerDefinition.make("Counter", {
 *   increment: WorkerDefinition.method({
 *     args: [Schema.Number],
 *     success: Schema.Number,
 *   }),
 * });
 *
 * const CounterLive = Counter.layer({ binding: "COUNTER" });
 *
 * const program = Effect.gen(function* () {
 *   const counter = yield* Counter;
 *   const next = yield* counter.increment(1);
 *   return next;
 * });
 * ```
 */
declare const Service: <Self, Api extends object = never>() => <Id extends string, const Definition extends Definition$6.Any | undefined = undefined>(id: Id, definition: ServiceBindingDefinition<Definition>) => BindingService<Self, Id, ServiceBindingEffectClient<ApiOrDefinition<Api, Definition>, Definition>> & DirectMethods$1<Self, Definition> & {
  readonly [TypeId$1]: typeof TypeId$1;
  readonly definition: ServiceBindingDefinition<Definition>;
  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<Response, ServiceBindingFetchError, Self>;
  readonly rpc: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Result$1<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, ServiceBindingRpcError, Self>;
  readonly call: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>, ServiceBindingRpcError, Self>;
  readonly scopedCall: <Method extends ServiceMethodKey<ApiOrDefinition<Api, Definition>>>(method: Method, ...args: ServiceMethodArgs<ApiOrDefinition<Api, Definition>, Method>) => Effect.Effect<Awaited<AsyncMethodSuccess<ApiOrDefinition<Api, Definition>, Method>>, unknown, Self | Scope.Scope>;
};
declare const makeDirectMethods$1: <R, Api, Definition extends Definition$6.Any | undefined>(rpcDefinition: Definition | undefined, call: ServiceCall<R, Api>) => DirectMethods$1<R, Definition>;
declare namespace Worker_d_exports {
  export { Api$2 as Api, Definition$5 as Definition, ExecutionContext, FetchHandler, FetchWorkerOptions, HandlerEffect$2 as HandlerEffect, Handlers$2 as Handlers, LayerOptions$10 as LayerOptions, Method$3 as Method, Methods$2 as Methods, NativeRequest, NoReservedMethods$2 as NoReservedMethods, Options$4 as Options, ReservedMethodName$3 as ReservedMethodName, RpcHandlers$1 as RpcHandlers, ServerApi$3 as ServerApi, ServiceFreeSchema$2 as ServiceFreeSchema, Tag$10 as Tag, TagClass$9 as TagClass, TagFactory$1 as TagFactory, WorkerClass, WorkerContext, WorkerContextService, WorkerContextWaitUntilOptions, WorkerFetchSuccess, WorkerHandler, WorkerOptions, WorkerRpc, WorkerRpcHandler, WorkerRpcShape, implement$4 as implement, isWebSocketUpgrade, make$8 as make, makeFetchHandler, method$2 as method, renderHttpResponse };
}
declare const ExecutionContext_base: Context.ServiceClass<ExecutionContext, "effect-cf/ExecutionContext", globalThis.ExecutionContext<unknown>>;
declare class ExecutionContext extends ExecutionContext_base {}
interface WorkerContextWaitUntilOptions<E, R> {
  readonly mode?: "observe" | "propagate";
  readonly onFailure?: (cause: Cause.Cause<E>) => Effect.Effect<void, never, R>;
}
interface WorkerContextService {
  readonly raw: globalThis.ExecutionContext;
  waitUntil<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: WorkerContextWaitUntilOptions<E, R2>): Effect.Effect<void, never, R | R2>;
  waitUntilPropagating<A, E, R, R2 = never>(effect: Effect.Effect<A, E, R>, options?: Omit<WorkerContextWaitUntilOptions<E, R2>, "mode">): Effect.Effect<void, never, R | R2>;
  readonly passThroughOnException: Effect.Effect<void>;
}
declare const WorkerContext_base: Context.ServiceClass<WorkerContext, "effect-cf/WorkerContext", WorkerContextService>;
declare class WorkerContext extends WorkerContext_base {}
declare const NativeRequest_base: Context.ServiceClass<NativeRequest, "effect-cf/NativeRequest", Request<unknown, CfProperties<unknown>>>;
declare class NativeRequest extends NativeRequest_base {}
declare const isWebSocketUpgrade: (request: Request) => boolean;
type ReservedMethodName$3 = ReservedMethodName$6 | "fetch" | "connect" | "queue" | "scheduled" | "tail" | "tailStream" | "test" | "trace" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
type WorkerBaseContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
type WorkerFetchContext<ROut> = WorkerBaseContext<ROut> | NativeRequest | HttpServerRequest.HttpServerRequest | Scope.Scope;
type WorkerRpcContext<ROut> = WorkerBaseContext<ROut> | Scope.Scope;
type WorkerFetchSuccess = Response | HttpServerResponse.HttpServerResponse;
type WorkerHandler<ROut, A = WorkerFetchSuccess> = Effect.Effect<A, unknown, WorkerFetchContext<ROut>>;
type WorkerRpcHandler<ROut, A = unknown> = Effect.Effect<A, unknown, WorkerRpcContext<ROut>>;
type WorkerRpc<ROut> = Record<string, (...args: Array<any>) => WorkerRpcHandler<ROut>>;
type WorkerRpcShape<Rpc extends WorkerRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, WorkerRpcContext<ROut>>) ? (...args: Args) => Promise<A> : never };
type RpcHandlers$1<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof WorkerEntrypoint ? never : Key extends string ? Key extends ReservedMethodName$3 ? never : [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<unknown>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => WorkerRpcHandler<ROut, A> : never };
interface WorkerOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends WorkerRpc<RRuntime | REvent> = Record<never, never>> {
  /**
   * Layer provided around each Cloudflare event handled by this Worker.
   *
   * The layer is built inside the event's Effect scope and finalized when the
   * event effect completes. Use this for event-scoped resources such as OTLP
   * trace/log exporters that should flush at event completion.
   */
  readonly eventLayer?: Layer.Layer<REvent, EventLayerError, WorkerBaseContext<RRuntime>>;
  readonly fetch?: Effect.Effect<WorkerFetchSuccess, unknown, WorkerFetchContext<RRuntime | REvent>>;
  readonly queue?: QueueHandler<RRuntime | REvent>;
  readonly rpc?: Rpc;
}
type FetchWorkerOptions<RRuntime, REvent = never, EventLayerError = never> = Omit<WorkerOptions<RRuntime, REvent, EventLayerError, Record<never, never>>, "rpc"> & {
  readonly rpc?: never;
};
type WorkerClass<Rpc extends WorkerRpc<ROut>, ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkerEntrypoint<WorkerEnv> & {
  fetch(request: Request): Promise<Response>;
  queue(batch: globalThis.MessageBatch): Promise<void>;
} & WorkerRpcShape<Rpc, ROut>;
interface FetchHandler<Env extends WorkerEnv = WorkerEnv> {
  readonly fetch: (request: Request, env: Env, ctx: globalThis.ExecutionContext) => Promise<Response>;
}
declare const renderHttpResponse: <A extends HttpServerResponse.HttpServerResponse, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<Response, E, R>;
declare function make$8<ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, fetch: WorkerHandler<ROut>): WorkerClass<Record<never, never>, ROut>;
declare function make$8<ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends WorkerRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkerOptions<ROut, REvent, EventLayerError, Rpc>): WorkerClass<Rpc, ROut | REvent>;
declare const makeFetchHandler: <ROut, LayerError, REvent = never, EventLayerError = never, Env extends WorkerEnv = WorkerEnv>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: FetchWorkerOptions<ROut, REvent, EventLayerError>) => FetchHandler<Env>;
type ServiceFreeSchema$2 = Schema.Codec<any, any, never, never>;
interface Method$3<Args extends ReadonlyArray<ServiceFreeSchema$2> = ReadonlyArray<ServiceFreeSchema$2>, Success extends ServiceFreeSchema$2 = ServiceFreeSchema$2> {
  readonly args: Args;
  readonly success: Success;
}
declare namespace Method$3 {
  export type Any = Method$3<ReadonlyArray<ServiceFreeSchema$2>, ServiceFreeSchema$2>;
  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$2>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$2, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$2>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
  export {};
}
type Methods$2 = Record<string, Method$3.Any>;
type NoReservedMethods$2<MethodsShape extends Methods$2> = Extract<keyof MethodsShape, ReservedMethodName$3> extends never ? MethodsShape : never;
interface Definition$5<Id extends string = string, MethodsShape extends Methods$2 = Methods$2> {
  readonly id: Id;
  readonly methods: MethodsShape;
}
declare namespace Definition$5 {
  type Any = Definition$5<string, Methods$2>;
}
type ServerApi$3<Self extends Definition$5.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$3.Args<Self["methods"][Key]>) => Promise<Method$3.Success<Self["methods"][Key]>> };
type Api$2<Self extends Definition$5.Any> = Provider<ServerApi$3<Self>, ReservedMethodName$3>;
type Handlers$2<ROut, Self extends Definition$5.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$3.Args<Self["methods"][Key]>) => WorkerRpcHandler<ROut, Method$3.Success<Self["methods"][Key]>> };
interface Options$4<ROut, Self extends Definition$5.Any, REvent = never, EventLayerError = never> extends Omit<WorkerOptions<ROut, REvent, EventLayerError, Handlers$2<ROut | REvent, Self>>, "rpc"> {
  readonly rpc: Handlers$2<ROut | REvent, Self>;
}
type LayerOptions$10 = LayerOptions$11;
type TagClass$9<Self, Id extends string, MethodsShape extends Methods$2> = Context.ServiceClass<Self, Id, ServiceBindingEffectClient<Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>>> & ServiceBindingStaticClient<Self, Api$2<Definition$5<Id, MethodsShape>>, Definition$5<Id, MethodsShape>> & {
  readonly id: Id;
  readonly methods: MethodsShape;
  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$4<ROut, Definition$5<Id, MethodsShape>, REvent, EventLayerError>) => WorkerClass<Handlers$2<ROut | REvent, Definition$5<Id, MethodsShape>>, ROut | REvent>;
  readonly layer: (options: LayerOptions$10) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
};
type TagFactory$1 = <Self>() => <Id extends string, const MethodsShape extends Methods$2>(id: Id, methods: MethodsShape & NoReservedMethods$2<MethodsShape>) => TagClass$9<Self, Id, MethodsShape>;
declare const Tag$10: TagFactory$1;
declare const method$2: {
  <Success extends ServiceFreeSchema$2>(definition: {
    readonly success: Success;
  }): Method$3<readonly [], Success>;
  <const Args extends ReadonlyArray<ServiceFreeSchema$2>, Success extends ServiceFreeSchema$2>(definition: {
    readonly args: Args;
    readonly success: Success;
  }): Method$3<Args, Success>;
};
declare const implement$4: <ROut, const Self extends Definition$5.Any>(_definition: Self, handlers: Handlers$2<ROut, Self>) => Handlers$2<ROut, Self>;
type HandlerEffect$2<ROut, Self extends Definition$5.Any, Key extends keyof Self["methods"]> = WorkerRpcHandler<ROut, Method$3.Success<Self["methods"][Key]>>;
declare namespace DurableObjectNamespace_d_exports {
  export { DurableObjectFetchError, DurableObjectNamespaceBindingDefinition, DurableObjectNamespaceClient, DurableObjectNamespaceDefinition, DurableObjectNamespaceEffectClient, DurableObjectNamespaceStaticClient, DurableObjectRpcError, DurableObjectStubClient, isDurableObjectNamespaceClient, layer$8 as layer, makeClient$6 as makeClient, makeDirectMethods };
}
interface DurableObjectFetcher {
  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
}
type RpcClient<Api> = { readonly [Key in keyof Api as Key extends string ? Api[Key] extends ((...args: Array<any>) => unknown) ? Key : never : never]: Api[Key] };
type ReservedMethodName$2 = ReservedMethodName$1 | "fetch";
/**
 * Cloudflare Durable Object stub, optionally enriched with RPC methods.
 */
type DurableObjectStubClient<Api extends object> = DurableObjectFetcher & RpcClient<Provider<Api, ReservedMethodName$2>> & {
  readonly id: globalThis.DurableObjectId;
  readonly name?: string;
};
/**
 * Native Durable Object namespace binding shape.
 */
interface DurableObjectNamespaceClient<Api extends object> {
  /** Creates a globally unique Durable Object id. */
  newUniqueId(options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions): globalThis.DurableObjectId;
  /** Deterministically maps a name to a Durable Object id. */
  idFromName(name: string): globalThis.DurableObjectId;
  /** Rehydrates a Durable Object id from its string form. */
  idFromString(id: string): globalThis.DurableObjectId;
  /** Returns a stub for an existing Durable Object id. */
  get(id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): DurableObjectStubClient<Api>;
  /** Returns a stub by deterministic name. */
  getByName(name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions): DurableObjectStubClient<Api>;
  /** Selects a namespace pinned to a specific jurisdiction. */
  jurisdiction(jurisdiction: globalThis.DurableObjectJurisdiction): DurableObjectNamespaceClient<Api>;
}
/**
 * Minimal namespace binding metadata.
 */
interface DurableObjectNamespaceDefinition {
  readonly binding: string;
}
/**
 * Namespace binding metadata with optional RPC schema.
 */
interface DurableObjectNamespaceBindingDefinition<Definition extends Definition$4.Any | undefined = undefined> {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
  /** Optional RPC schema used for argument/result encoding. */
  readonly definition?: Definition;
}
declare const DurableObjectRpcError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "DurableObjectRpcError";
} & Readonly<A>;
/**
 * Failure raised when invoking an RPC method on a Durable Object stub.
 */
declare class DurableObjectRpcError extends DurableObjectRpcError_base<{
  readonly binding: string;
  readonly method: string;
  readonly cause: unknown;
}> {}
declare const DurableObjectFetchError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "DurableObjectFetchError";
} & Readonly<A>;
/**
 * Failure raised when forwarding a request to a Durable Object stub.
 */
declare class DurableObjectFetchError extends DurableObjectFetchError_base<{
  readonly binding: string;
  readonly cause: unknown;
}> {}
type StubMethodKey<Api> = AsyncMethodKey<Api>;
type StubMethodArgs<Api, Method extends keyof Api> = AsyncMethodArgs<Api, Method>;
type StubMethodSuccess<Api, Method extends keyof Api> = AsyncMethodSuccess<Api, Method>;
type StubMethodCloudflareReturn<Api, Method extends keyof Api> = AsyncMethodCloudflareReturn<Api, Method>;
type StubCall<R, Api extends object> = <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
type DefinitionNamespaceDirectMethods<R, Api extends object, Definition extends Definition$4.Any> = { readonly [Method in Definition$9.MethodNames<Definition>]: (stub: DurableObjectStubClient<Api>, ...args: Method$5.Args<Definition["methods"][Method]>) => Effect.Effect<Method$5.Success<Definition["methods"][Method]>, DurableObjectRpcError, R> };
type DefinitionDurableObjectDirectClient<R, Definition extends Definition$4.Any> = {
  readonly fetch: (input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
} & { readonly [Method in Definition$9.MethodNames<Definition>]: (...args: Method$5.Args<Definition["methods"][Method]>) => Effect.Effect<Method$5.Success<Definition["methods"][Method]>, DurableObjectRpcError, R> };
type DefinitionNamespaceDirectClientMethods<R, Definition extends Definition$4.Any> = {
  readonly byName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => DefinitionDurableObjectDirectClient<R, Definition>;
  readonly byId: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => DefinitionDurableObjectDirectClient<R, Definition>;
};
type DirectMethods<R, Api extends object, Definition> = Definition extends Definition$4.Any ? DefinitionNamespaceDirectMethods<R, Api, Definition> & DefinitionNamespaceDirectClientMethods<R, Definition> : {};
type DurableObjectNamespaceEffectClient<Api extends object, Definition extends Definition$4.Any | undefined = undefined> = DirectMethods<never, Api, Definition> & {
  /** Creates a globally unique Durable Object id. */readonly newUniqueId: (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) => Effect.Effect<globalThis.DurableObjectId>; /** Deterministically maps a name to a Durable Object id. */
  readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId>; /** Rehydrates a Durable Object id from its string form. */
  readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId>; /** Returns a stub for an existing Durable Object id. */
  readonly get: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>>; /** Returns a stub by deterministic name. */
  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>>; /** Selects a namespace pinned to a specific jurisdiction. */
  readonly jurisdiction: (jurisdiction: globalThis.DurableObjectJurisdiction) => Effect.Effect<DurableObjectNamespaceClient<Api>>;
  /**
   * Forwards an HTTP request to a Durable Object stub.
   *
   * Use this for fetch-based Durable Object APIs, including WebSocket upgrade
   * forwarding where the native response must be preserved.
   *
   * @example
   * ```ts
   * import { Effect } from "effect";
   *
   * const program = Effect.gen(function* () {
   *   const rooms = yield* ChatRooms;
   *   const room = yield* rooms.getByName("general");
   *
   *   return yield* rooms.fetch(room, new Request("https://worker.example/room"));
   * });
   * ```
   */
  readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError>;
  /**
   * Invokes a Durable Object RPC method and returns Cloudflare's raw RPC result.
   *
   * This preserves Cloudflare RPC behavior such as promise-like pipelining and
   * transferable / disposable result objects. It does not resolve the returned
   * promise-like value and it does not decode definition-backed success schemas.
   *
   * Most application code should use {@link call} instead.
   *
   * @example
   * ```ts
   * import { Effect } from "effect";
   *
   * const program = Effect.gen(function* () {
   *   const counters = yield* Counters;
   *   const counter = yield* counters.getByName("main");
   *
   *   const result = yield* counters.rpc(counter, "get");
   *   const value = yield* Effect.promise(() => result);
   *
   *   return value;
   * });
   * ```
   */
  readonly rpc: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError>;
  /**
   * Invokes a Durable Object RPC method, resolves Cloudflare's RPC result, and
   * decodes the success value when the namespace was created from a definition.
   *
   * This is the normal choice when application code wants the final typed value.
   *
   * @example
   * ```ts
   * import { Effect } from "effect";
   *
   * const program = Effect.gen(function* () {
   *   const counters = yield* Counters;
   *   const counter = yield* counters.getByName("main");
   *
   *   return yield* counters.call(counter, "increment", 1);
   * });
   * ```
   */
  readonly call: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError>;
  /**
   * Invokes a Durable Object RPC method in the current `Scope`, resolves
   * Cloudflare's RPC result, decodes definition-backed success values, and
   * disposes the resolved result when the scope closes if it implements
   * `Symbol.dispose`.
   *
   * Use this for RPC methods that return Cloudflare RPC resources or other
   * disposable objects whose lifetime should be tied to an Effect scope.
   *
   * @example
   * ```ts
   * import { Effect } from "effect";
   *
   * const program = Effect.scoped(
   *   Effect.gen(function* () {
   *     const rooms = yield* ChatRooms;
   *     const room = yield* rooms.getByName("general");
   *     const handle = yield* rooms.scopedCall(room, "openStream");
   *
   *     return yield* handle.read();
   *   }),
   * );
   * ```
   */
  readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope>;
  /**
   * Exposes the underlying native Durable Object namespace binding.
   *
   * Prefer the typed helpers above unless Cloudflare exposes a platform feature
   * that is not wrapped by effect-cf yet.
   */
  readonly unsafeRaw: Effect.Effect<DurableObjectNamespaceClient<Api>>;
};
type DurableObjectNamespaceStaticClient<R, Api extends object, Definition extends Definition$4.Any | undefined = undefined> = DirectMethods<R, Api, Definition> & {
  readonly newUniqueId: (options?: globalThis.DurableObjectNamespaceNewUniqueIdOptions) => Effect.Effect<globalThis.DurableObjectId, never, R>;
  readonly idFromName: (name: string) => Effect.Effect<globalThis.DurableObjectId, never, R>;
  readonly idFromString: (id: string) => Effect.Effect<globalThis.DurableObjectId, never, R>;
  readonly get: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
  readonly jurisdiction: (jurisdiction: globalThis.DurableObjectJurisdiction) => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
  readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
  readonly rpc: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodCloudflareReturn<Api, Method>, DurableObjectRpcError, R>;
  readonly call: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<StubMethodSuccess<Api, Method>, DurableObjectRpcError, R>;
  readonly scopedCall: <Method extends StubMethodKey<Api>>(stub: DurableObjectStubClient<Api>, method: Method, ...args: StubMethodArgs<Api, Method>) => Effect.Effect<Awaited<StubMethodSuccess<Api, Method>>, unknown, Scope.Scope | R>;
  readonly unsafeRaw: () => Effect.Effect<DurableObjectNamespaceClient<Api>, never, R>;
};
declare const isDurableObjectNamespaceClient: <Api extends object>(value: unknown) => value is DurableObjectNamespaceClient<Api>;
declare const makeClient$6: <Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(definition: DurableObjectNamespaceBindingDefinition<Definition>) => ((namespace: DurableObjectNamespaceClient<Api>) => DurableObjectNamespaceEffectClient<Api, Definition>);
declare const layer$8: <Self, Api extends object, const Definition extends Definition$4.Any | undefined = undefined>(tag: Context.Service<Self, DurableObjectNamespaceEffectClient<Api, Definition>>, definition: DurableObjectNamespaceBindingDefinition<Definition>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare const makeDirectMethods: <R, Api extends object, Definition extends Definition$4.Any | undefined>(rpcDefinition: Definition | undefined, helpers: {
  readonly call: StubCall<R, Api>;
  readonly fetch: (stub: DurableObjectStubClient<Api>, input: RequestInfo | URL, init?: RequestInit) => Effect.Effect<globalThis.Response, DurableObjectFetchError, R>;
  readonly get: (id: globalThis.DurableObjectId, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
  readonly getByName: (name: string, options?: globalThis.DurableObjectNamespaceGetDurableObjectOptions) => Effect.Effect<DurableObjectStubClient<Api>, never, R>;
}) => DirectMethods<R, Api, Definition>;
declare namespace DurableObjectDefinition_d_exports {
  export { Api$1 as Api, Definition$4 as Definition, DurableObject$1 as DurableObject, HandlerEffect$1 as HandlerEffect, Handlers$1 as Handlers, LayerOptions$9 as LayerOptions, Method$2 as Method, Methods$1 as Methods, NoReservedMethods$1 as NoReservedMethods, Options$3 as Options, ReservedMethodName$1 as ReservedMethodName, ServerApi$2 as ServerApi, ServiceFreeSchema$1 as ServiceFreeSchema, Tag$9 as Tag, TagClass$8 as TagClass, implement$3 as implement, make$7 as make, method$1 as method };
}
type ServiceFreeSchema$1 = Schema.Codec<any, any, never, never>;
interface Method$2<Args extends ReadonlyArray<ServiceFreeSchema$1> = ReadonlyArray<ServiceFreeSchema$1>, Success extends ServiceFreeSchema$1 = ServiceFreeSchema$1> {
  readonly args: Args;
  readonly success: Success;
}
declare namespace Method$2 {
  export type Any = Method$2<ReadonlyArray<ServiceFreeSchema$1>, ServiceFreeSchema$1>;
  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$1>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
  type EncodedArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema$1>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema$1, ...infer Tail extends ReadonlyArray<ServiceFreeSchema$1>] ? [Schema.Codec.Encoded<Head>, ...EncodedArgsFromSchemas<Tail>] : Array<Schema.Codec.Encoded<Args[number]>>;
  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
  export type EncodedArgs<Self extends Any> = EncodedArgsFromSchemas<Self["args"]>;
  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
  export type EncodedSuccess<Self extends Any> = Schema.Codec.Encoded<Self["success"]>;
  export {};
}
type Methods$1 = Record<string, Method$2.Any>;
/**
 * RPC contract for a Durable Object class.
 */
interface Definition$4<Id extends string = string, MethodsShape extends Methods$1 = Methods$1> {
  readonly id: Id;
  readonly methods: MethodsShape;
}
declare namespace Definition$4 {
  type Any = Definition$4<string, Methods$1>;
}
type ReservedMethodName$1 = ReservedMethodName$6 | "fetch" | "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError";
type NoReservedMethods$1<MethodsShape extends Methods$1> = Extract<keyof MethodsShape, ReservedMethodName$1> extends never ? MethodsShape : never;
/**
 * Promise-based client API derived from a Durable Object definition.
 */
type ServerApi$2<Self extends Definition$4.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$2.Args<Self["methods"][Key]>) => Promise<Method$2.Success<Self["methods"][Key]>> };
type Api$1<Self extends Definition$4.Any> = Provider<ServerApi$2<Self>, ReservedMethodName$1>;
/**
 * Effect handlers for each RPC method in a Durable Object definition.
 */
type Handlers$1<ROut, Self extends Definition$4.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$2.Args<Self["methods"][Key]>) => DurableObjectHandler<ROut, Method$2.Success<Self["methods"][Key]>> };
/**
 * Durable Object constructor options for a specific RPC definition.
 */
interface Options$3<ROut, Self extends Definition$4.Any, REvent = never, EventLayerError = never> extends Omit<DurableObjectOptions<ROut, REvent, EventLayerError, Handlers$1<ROut | REvent, Self>>, "rpc"> {
  readonly rpc: Handlers$1<ROut | REvent, Self>;
}
type LayerOptions$9 = {
  readonly binding: string;
};
type TagClass$8<Self, Id extends string, MethodsShape extends Methods$1> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api$1<Definition$4<Id, MethodsShape>>, Definition$4<Id, MethodsShape>> & {
  readonly id: Id;
  readonly methods: MethodsShape;
  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$3<ROut, Definition$4<Id, MethodsShape>, REvent, EventLayerError>) => DurableObjectClass<Handlers$1<ROut | REvent, Definition$4<Id, MethodsShape>>, ROut | REvent>;
  readonly layer: (options: LayerOptions$9) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
};
/**
 * Defines a single RPC method schema in a Durable Object definition.
 */
declare const method$1: {
  <Success extends ServiceFreeSchema$1>(definition: {
    readonly success: Success;
  }): Method$2<readonly [], Success>;
  <const Args extends readonly ServiceFreeSchema$1[], Success extends ServiceFreeSchema$1>(definition: {
    readonly args: Args;
    readonly success: Success;
  }): Method$2<Args, Success>;
};
declare const make$7: <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$8<Definition$4<Id, MethodsShape>, Id, MethodsShape>;
declare const Tag$9: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
declare const DurableObject$1: <Self>() => <Id extends string, const MethodsShape extends Methods$1>(id: Id, methods: MethodsShape & NoReservedMethods$1<MethodsShape>) => TagClass$8<Self, Id, MethodsShape>;
/**
 * Helper for implementing handlers with the exact method shape of a definition.
 */
declare const implement$3: <ROut, const Self extends Definition$4.Any>(_definition: Self, handlers: Handlers$1<ROut, Self>) => Handlers$1<ROut, Self>;
/**
 * Convenience alias for a single Durable Object RPC handler Effect.
 */
type HandlerEffect$1<ROut, Self extends Definition$4.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$2.Success<Self["methods"][Key]>>;
declare namespace DurableObject_d_exports {
  export { Api, Definition$3 as Definition, DurableObjectClass, DurableObjectHandler, DurableObjectOptions, DurableObjectRpc, DurableObjectRpcShape, HandlerEffect, Handlers, LayerOptions$8 as LayerOptions, Method$1 as Method, Methods, NoReservedMethods, Options$2 as Options, ReservedMethodName, RpcHandlers, ServerApi$1 as ServerApi, ServiceFreeSchema, Tag$8 as Tag, TagClass$7 as TagClass, TagFactory, implement$2 as implement, make$6 as make, method };
}
type RuntimeContext$1<ROut> = DurableObjectState | WorkerEnvironment | ROut;
type HandlerContext<ROut> = RuntimeContext$1<ROut> | Scope.Scope;
type FetchContext<ROut> = HandlerContext<ROut> | NativeRequest;
/**
 * Effect type for Durable Object lifecycle and RPC handlers.
 */
type DurableObjectHandler<ROut, A = unknown> = Effect.Effect<A, unknown, HandlerContext<ROut>>;
/**
 * Shape of Durable Object RPC handlers passed to {@link make}.
 */
type DurableObjectRpc<ROut> = Record<string, (...args: Array<any>) => DurableObjectHandler<ROut>>;
type DurableObjectRpcShape<Rpc extends DurableObjectRpc<ROut>, ROut> = { readonly [Key in keyof Rpc]: Rpc[Key] extends ((...args: infer Args) => Effect.Effect<infer A, unknown, HandlerContext<ROut>>) ? (...args: Args) => Promise<A> : never };
type RpcHandlers<ROut, Api> = { readonly [Key in keyof Api as Key extends keyof DurableObject<WorkerEnv> ? never : Key extends string ? [Api[Key]] extends [never] ? never : Api[Key] extends ((...args: Array<any>) => Promise<unknown>) ? Key : never : never]: Api[Key] extends ((...args: infer Args) => Promise<infer A>) ? (...args: Args) => DurableObjectHandler<ROut, A> : never };
/**
 * Options for creating a Durable Object class backed by Effect handlers.
 */
interface DurableObjectOptions<RRuntime, REvent = never, EventLayerError = never, Rpc extends DurableObjectRpc<RRuntime | REvent> = Record<never, never>> {
  /**
   * Layer provided around each Cloudflare event handled by this Durable Object.
   *
   * The layer is built inside the event's Effect scope and finalized when the
   * event effect completes. It is not applied to `initialize`, which is an
   * instance-load lifecycle hook rather than a platform event.
   */
  readonly eventLayer?: Layer.Layer<REvent, EventLayerError, DurableObjectState | WorkerEnvironment | RRuntime>;
  /**
   * Effect run when Cloudflare loads this Durable Object instance into memory.
   *
   * Use `DurableObjectState.blockConcurrencyWhile` inside this hook when
   * incoming events should wait for setup to finish. Cloudflare may construct
   * the same Durable Object id again after eviction or restart; use Durable
   * Object storage if work must happen only once per id.
   */
  readonly initialize?: Effect.Effect<void, unknown, HandlerContext<RRuntime>>;
  /** Optional RPC methods exposed as Durable Object instance methods. */
  readonly rpc?: Rpc;
  /** Optional fetch handler for HTTP/WebSocket requests. */
  readonly fetch?: Effect.Effect<Response, unknown, FetchContext<RRuntime | REvent>>;
  /**
   * Optional logical alarm processing effect.
   *
   * This runs before `alarm` and should be built with helpers such as
   * `DurableObjectAlarm.processDue(...)` so the reusable scheduler stays inside
   * the Durable Object's single managed runtime boundary.
   */
  readonly alarms?: Effect.Effect<unknown, unknown, HandlerContext<RRuntime | REvent>>;
  readonly alarm?: (alarmInfo?: globalThis.AlarmInvocationInfo) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
  readonly webSocketMessage?: (socket: DurableWebSocket, message: string | ArrayBuffer) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
  readonly webSocketClose?: (socket: DurableWebSocket, code: number, reason: string, wasClean: boolean) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
  readonly webSocketError?: (socket: DurableWebSocket, error: unknown) => Effect.Effect<void, unknown, HandlerContext<RRuntime | REvent>>;
}
/**
 * Cloudflare `DurableObject` constructor produced by {@link make}.
 */
type DurableObjectClass<Rpc extends DurableObjectRpc<ROut>, ROut> = new (state: globalThis.DurableObjectState, env: WorkerEnv) => DurableObject<WorkerEnv> & DurableObjectRpcShape<Rpc, ROut>;
/**
 * Creates a Durable Object class backed by a single managed Effect runtime.
 */
declare const make$6: <ROut, LayerError, REvent = never, EventLayerError = never, const Rpc extends DurableObjectRpc<ROut | REvent> = Record<never, never>>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options?: DurableObjectOptions<ROut, REvent, EventLayerError, Rpc>) => DurableObjectClass<Rpc, ROut | REvent>;
type ServiceFreeSchema = Schema.Codec<any, any, never, never>;
interface Method$1<Args extends ReadonlyArray<ServiceFreeSchema> = ReadonlyArray<ServiceFreeSchema>, Success extends ServiceFreeSchema = ServiceFreeSchema> {
  readonly args: Args;
  readonly success: Success;
}
declare namespace Method$1 {
  export type Any = Method$1<ReadonlyArray<ServiceFreeSchema>, ServiceFreeSchema>;
  type ArgsFromSchemas<Args extends ReadonlyArray<ServiceFreeSchema>> = Args extends readonly [] ? [] : Args extends readonly [infer Head extends ServiceFreeSchema, ...infer Tail extends ReadonlyArray<ServiceFreeSchema>] ? [Schema.Schema.Type<Head>, ...ArgsFromSchemas<Tail>] : Array<Schema.Schema.Type<Args[number]>>;
  export type Args<Self extends Any> = ArgsFromSchemas<Self["args"]>;
  export type Success<Self extends Any> = Schema.Schema.Type<Self["success"]>;
  export {};
}
type Methods = Record<string, Method$1.Any>;
type ReservedMethodName = ReservedMethodName$1;
type NoReservedMethods<MethodsShape extends Methods> = Extract<keyof MethodsShape, ReservedMethodName> extends never ? MethodsShape : never;
interface Definition$3<Id extends string = string, MethodsShape extends Methods = Methods> {
  readonly id: Id;
  readonly methods: MethodsShape;
}
declare namespace Definition$3 {
  type Any = Definition$3<string, Methods>;
}
type LayerOptions$8 = LayerOptions$9;
type ServerApi$1<Self extends Definition$3.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$1.Args<Self["methods"][Key]>) => Promise<Method$1.Success<Self["methods"][Key]>> };
type Api<Self extends Definition$3.Any> = Provider<ServerApi$1<Self>, ReservedMethodName>;
type Handlers<ROut, Self extends Definition$3.Any> = { readonly [Key in keyof Self["methods"]]: (...args: Method$1.Args<Self["methods"][Key]>) => DurableObjectHandler<ROut, Method$1.Success<Self["methods"][Key]>> };
interface Options$2<ROut, Self extends Definition$3.Any, REvent = never, EventLayerError = never> extends Omit<DurableObjectOptions<ROut, REvent, EventLayerError, Handlers<ROut | REvent, Self>>, "rpc"> {
  readonly rpc: Handlers<ROut | REvent, Self>;
}
type TagClass$7<Self, Id extends string, MethodsShape extends Methods> = Context.ServiceClass<Self, Id, DurableObjectNamespaceEffectClient<Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>>> & DurableObjectNamespaceStaticClient<Self, Api<Definition$3<Id, MethodsShape>>, Definition$3<Id, MethodsShape>> & {
  readonly id: Id;
  readonly methods: MethodsShape;
  readonly make: <ROut, LayerError, REvent = never, EventLayerError = never>(layer: Layer.Layer<ROut, LayerError, DurableObjectState | WorkerEnvironment>, options: Options$2<ROut, Definition$3<Id, MethodsShape>, REvent, EventLayerError>) => DurableObjectClass<Handlers<ROut | REvent, Definition$3<Id, MethodsShape>>, ROut | REvent>;
  readonly layer: (options: LayerOptions$8) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
};
type TagFactory = <Self>() => <Id extends string, const MethodsShape extends Methods>(id: Id, methods: MethodsShape & NoReservedMethods<MethodsShape>) => TagClass$7<Self, Id, MethodsShape>;
declare const Tag$8: TagFactory;
declare const method: {
  <Success extends ServiceFreeSchema>(definition: {
    readonly success: Success;
  }): Method$1<readonly [], Success>;
  <const Args extends readonly ServiceFreeSchema[], Success extends ServiceFreeSchema>(definition: {
    readonly args: Args;
    readonly success: Success;
  }): Method$1<Args, Success>;
};
declare const implement$2: <ROut, const Self extends Definition$3.Any>(_definition: Self, handlers: Handlers<ROut, Self>) => Handlers<ROut, Self>;
type HandlerEffect<ROut, Self extends Definition$3.Any, Key extends keyof Self["methods"]> = DurableObjectHandler<ROut, Method$1.Success<Self["methods"][Key]>>;
declare namespace DurableObjectAlarm_d_exports {
  export { AlarmDefinitionConfig, AlarmDefinitionEntry, AlarmDefinitionPayload, AlarmDefinitions, AlarmFailurePolicy, AlarmPayload, AlarmPayloadSchema, AlarmRef, AlarmRetryPolicy, AlarmScheduler, DefinedAlarmEvent, DefinedAlarmHandlers, DurableObjectAlarm, DurableObjectAlarmError, DurableObjectAlarmEvent, InvalidAlarmPayloadError, InvalidAlarmRefError, InvalidProcessDueAlarmsOptionsError, InvalidRepeatEveryError, ProcessDueAlarmsFailure, ProcessDueAlarmsFailureAction, ProcessDueAlarmsHandler, ProcessDueAlarmsMode, ProcessDueAlarmsOptions, ProcessDueAlarmsResult, ScheduleAlarmInput, StoredAlarmDecodeError, define, process, processDue };
}
/**
 * JSON-serializable alarm payload stored with each scheduled alarm.
 *
 * Payloads are intentionally opaque to `DurableObjectAlarm`. Consumers should use
 * stable `tag` values to route due alarms and then decode the payload for that
 * tag in their own domain layer.
 */
type AlarmPayload = Schema.Json;
declare const InvalidAlarmRefError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "InvalidAlarmRefError";
} & Readonly<A>;
declare class InvalidAlarmRefError extends InvalidAlarmRefError_base<{
  readonly cause: unknown;
}> {}
declare const InvalidAlarmPayloadError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "InvalidAlarmPayloadError";
} & Readonly<A>;
declare class InvalidAlarmPayloadError extends InvalidAlarmPayloadError_base<{
  readonly cause: unknown;
}> {}
declare const InvalidRepeatEveryError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "InvalidRepeatEveryError";
} & Readonly<A>;
declare class InvalidRepeatEveryError extends InvalidRepeatEveryError_base<{
  readonly cause: unknown;
}> {}
declare const InvalidProcessDueAlarmsOptionsError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "InvalidProcessDueAlarmsOptionsError";
} & Readonly<A>;
declare class InvalidProcessDueAlarmsOptionsError extends InvalidProcessDueAlarmsOptionsError_base<{
  readonly cause: unknown;
}> {}
declare const StoredAlarmDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "StoredAlarmDecodeError";
} & Readonly<A>;
declare class StoredAlarmDecodeError extends StoredAlarmDecodeError_base<{
  readonly cause: unknown;
  readonly storageId: string;
}> {}
type DurableObjectAlarmError = InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidProcessDueAlarmsOptionsError | InvalidRepeatEveryError | StorageOperationError | StoredAlarmDecodeError;
/**
 * Events handled by `processDueAlarms`.
 *
 * `AlarmDue` represents one durable alarm whose scheduled time is now due. The
 * `tag` is the consumer-owned routing key, while `id` is the stable alarm id
 * within that tag.
 *
 * `scheduledAt` is the logical due-after timestamp from durable storage. It is
 * not expected to match the current Durable Object alarm invocation time,
 * especially during retries. Retries re-scan durable rows with `run_at <= now`
 * and identify logical events by `{ tag, id }`.
 *
 * @example Handling events by tag
 * ```ts
 * yield* durableObjectAlarm.processDueAlarms((event) =>
 *   event.tag === "heartbeat"
 *     ? heartbeatManager.handleAlarmEvent(event).pipe(Effect.asVoid)
 *     : Effect.void
 * );
 * ```
 */
declare const DurableObjectAlarmEvent: Schema.TaggedUnion<{
  readonly AlarmDue: Schema.TaggedStruct<"AlarmDue", {
    readonly id: Schema.NonEmptyString;
    readonly payload: Schema.Codec<Schema.Json, Schema.Json, never, never>;
    readonly scheduledAt: Schema.DateTimeUtc;
    readonly tag: Schema.NonEmptyString;
  }>;
}>;
type DurableObjectAlarmEvent = typeof DurableObjectAlarmEvent.Type;
/**
 * Stable reference for a scheduled alarm.
 *
 * The pair of `tag` and `id` is the durable identity. Scheduling another alarm
 * with the same pair replaces the previous alarm, and cancellation uses the
 * same pair.
 *
 * @example Cancel an alarm
 * ```ts
 * yield* durableObjectAlarm.cancelAlarm({
 *   tag: "connection-reconnect-grace",
 *   id: "reconnect-grace-check",
 * });
 * ```
 */
type AlarmRef<Tag extends string = string> = {
  readonly id: string;
  readonly tag: Tag;
};
/**
 * Input for scheduling or replacing an alarm.
 *
 * `runAt` is the absolute first fire time. `repeatEvery` can be any Effect
 * `Duration.Input`, including strings like `"5 seconds"`, numbers interpreted
 * as milliseconds, or `Duration` values.
 *
 * @example One-shot alarm
 * ```ts
 * const now = yield* DateTime.now;
 *
 * yield* durableObjectAlarm.scheduleAlarm({
 *   tag: "connection-reconnect-grace",
 *   id: "reconnect-grace-check",
 *   runAt: DateTime.add(now, { seconds: 15 }),
 *   payload: { reason: "socket-closed" },
 * });
 * ```
 *
 * @example Repeating alarm
 * ```ts
 * const now = yield* DateTime.now;
 *
 * yield* durableObjectAlarm.scheduleAlarm({
 *   tag: "heartbeat",
 *   id: "heartbeat-check",
 *   runAt: DateTime.add(now, { seconds: 5 }),
 *   repeatEvery: "5 seconds",
 *   payload: null,
 * });
 * ```
 */
type ScheduleAlarmInput<Tag extends string = string> = AlarmRef<Tag> & {
  readonly payload: AlarmPayload;
  readonly repeatEvery?: Duration.Input;
  readonly runAt: DateTime.Utc;
};
type ProcessDueAlarmsMode = "isolated" | "ordered";
interface ProcessDueAlarmsFailure {
  readonly cause: unknown;
  readonly event?: DurableObjectAlarmEvent;
  readonly id: string;
  readonly storageId: string;
  readonly tag: string;
}
interface ProcessDueAlarmsResult {
  readonly failed: readonly ProcessDueAlarmsFailure[];
  readonly handled: readonly DurableObjectAlarmEvent[];
}
type ProcessDueAlarmsFailureAction = "ordered" | "retry" | "skip-and-advance-repeat" | {
  readonly mode: "ordered";
} | {
  readonly mode: "retry";
  readonly retryFailedAfter?: Duration.Input;
} | {
  readonly mode: "skip-and-advance-repeat";
};
interface ProcessDueAlarmsOptions<OnFailureR = never, OnFailureE = never> {
  /** Maximum due rows to load and process in one invocation. Defaults to 100. */
  readonly limit?: number;
  /**
   * Failure isolation mode. Defaults to `isolated` so one poison logical alarm
   * does not block unrelated maintenance work.
   */
  readonly mode?: ProcessDueAlarmsMode;
  /**
   * Callback for logical handler/decode failures. Return a failure action to
   * override the global failure behavior for this row.
   */
  readonly onFailure?: (failure: ProcessDueAlarmsFailure) => Effect.Effect<ProcessDueAlarmsFailureAction | void, OnFailureE, OnFailureR>;
  /**
   * Delay before retrying a failed logical row in isolated mode. Defaults to 30
   * seconds. Ignored by ordered mode unless supplied explicitly.
   *
   * Retrying updates only the selected occurrence, so replacements scheduled by
   * a long-running handler are not clobbered by failure handling.
   */
  readonly retryFailedAfter?: Duration.Input;
}
/**
 * Handler invoked for each due alarm before that alarm is acknowledged.
 *
 * If the handler fails, `DurableObjectAlarm` leaves the row due and fails the alarm
 * processing effect. Cloudflare can then retry the Durable Object alarm handler,
 * and the scheduler will find the same logical row again because `run_at` is
 * still less than or equal to the retry time.
 */
type ProcessDueAlarmsHandler<R = never, E = never> = (event: DurableObjectAlarmEvent) => Effect.Effect<void, E, R>;
/**
 * Durable alarm scheduler API.
 *
 * This service only owns scheduling semantics. It does not publish, subscribe,
 * or dispatch events to consumers. Durable Object alarm handlers should pass a
 * domain handler to `processDueAlarms`; rows are acknowledged only after that
 * handler succeeds.
 *
 * This service must be the only code path that owns `storage.setAlarm()` inside
 * a Durable Object instance. Cloudflare exposes one platform alarm timestamp per
 * object, so another scheduler in the same object can clobber this service's
 * reconciled alarm timestamp.
 *
 * @example Durable Object alarm handler
 * ```ts
 * const onAlarm = Effect.gen(function* () {
 *   const durableObjectAlarm = yield* DurableObjectAlarm;
 *
 *   yield* durableObjectAlarm.processDueAlarms((event) =>
 *     Effect.gen(function* () {
 *       if (event.tag === "heartbeat") {
 *         yield* heartbeatManager.handleAlarmEvent(event);
 *         return;
 *       }
 *
 *       if (event.tag === "connection-reconnect-grace") {
 *         yield* connectionManager.expireReconnectGracePeriods();
 *       }
 *     })
 *   );
 * });
 * ```
 */
type AlarmScheduler = {
  /**
   * Cancel a scheduled alarm by `{ tag, id }`.
   *
   * This is idempotent. Cancelling a missing alarm is a no-op. The underlying
   * Durable Object alarm is reconciled afterward.
   */
  readonly cancelAlarm: (input: AlarmRef) => Effect.Effect<void, InvalidAlarmRefError | StorageOperationError>;
  /**
   * Process due alarms according to `Clock.currentTimeMillis`.
   *
   * Each row is acknowledged only after `handle` succeeds. One-shot alarms are
   * then deleted. Repeating alarms are rescheduled to `acknowledgedAt +
   * repeatEvery`, which intentionally behaves as delay-after-success rather
   * than fixed-cadence catch-up. Acknowledgements are conditional on the stored
   * row still matching the selected occurrence, so a handler that reschedules
   * the same `{ tag, id }` will not have its replacement clobbered by the old
   * acknowledgement.
   *
   * Processing is ordered by `runAt` and stable alarm id. By default, logical
   * handler/decode failures are isolated to the failing row: the row is retried
   * after `retryFailedAfter`, later due rows still run, and the result reports
   * both handled and failed rows. Use `mode: "ordered"` when a workflow
   * intentionally requires strict head-of-line blocking.
   *
   * Handlers must still be idempotent: Cloudflare alarms are at-least-once, and
   * if a handler succeeds but the acknowledgement write fails, the logical event
   * can be delivered again.
   */
  readonly processDueAlarms: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, R | OnFailureR>;
  /**
   * Schedule or replace an alarm by `{ tag, id }`.
   *
   * The durable row write and underlying platform alarm reconciliation are run
   * in one Durable Object storage transaction, so a failed `setAlarm` rolls back
   * the logical schedule instead of leaving a stored-but-unarmed alarm.
   */
  readonly scheduleAlarm: (input: ScheduleAlarmInput) => Effect.Effect<void, InvalidAlarmPayloadError | InvalidAlarmRefError | InvalidRepeatEveryError | StorageOperationError>;
};
declare const processDue: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, OnFailureR | R | DurableObjectAlarm>;
declare const process: <R = never, E = never, OnFailureR = never, OnFailureE = never>(handle: ProcessDueAlarmsHandler<R, E>, options?: ProcessDueAlarmsOptions<OnFailureR, OnFailureE>) => Effect.Effect<ProcessDueAlarmsResult, E | OnFailureE | DurableObjectAlarmError, OnFailureR | R | DurableObjectAlarm>;
type AlarmPayloadSchema = Schema.Codec<any, any, never, never>;
type AlarmFailurePolicy = "ordered" | "retry" | "skip-and-advance-repeat";
interface AlarmRetryPolicy {
  readonly initialDelay?: Duration.Input;
}
interface AlarmDefinitionConfig<Payload extends AlarmPayloadSchema = AlarmPayloadSchema> {
  readonly failure?: AlarmFailurePolicy;
  readonly payload: Payload;
  readonly retry?: AlarmRetryPolicy;
}
type AlarmDefinitionEntry = AlarmDefinitionConfig | AlarmPayloadSchema;
type AlarmDefinitions = Readonly<Record<string, AlarmDefinitionEntry>>;
type AlarmDefinitionSchema<Definition> = Definition extends AlarmDefinitionConfig<infer Payload> ? Payload : Definition;
type AlarmDefinitionPayload<Definition> = AlarmDefinitionSchema<Definition> extends Schema.Codec<infer A, any, never, never> ? A : never;
type DefinedAlarmEvent<Tag extends string, Payload> = Omit<DurableObjectAlarmEvent, "payload" | "tag"> & {
  readonly payload: Payload;
  readonly tag: Tag;
};
type DefinedAlarmHandlers<Definitions extends AlarmDefinitions, R = never, E = never> = { readonly [Tag in keyof Definitions & string]: (event: DefinedAlarmEvent<Tag, AlarmDefinitionPayload<Definitions[Tag]>>) => Effect.Effect<void, E, R> };
declare const define: <const Definitions extends AlarmDefinitions>(definitions: Definitions) => {
  handlers: <R = never, E = never>(handlers: DefinedAlarmHandlers<Definitions, R, E>, options?: ProcessDueAlarmsOptions<R, E>) => Effect.Effect<ProcessDueAlarmsResult, E | DurableObjectAlarmError, R | DurableObjectAlarm>;
};
declare const DurableObjectAlarm_base: Context.ServiceClass<DurableObjectAlarm, "effect-cf/DurableObjectAlarm", AlarmScheduler>;
/**
 * SQLite-backed Durable Object alarm scheduler.
 *
 * `DurableObjectAlarm` stores alarms in the current Durable Object's SQLite storage
 * and keeps the platform alarm set to the earliest pending scheduled alarm. The
 * platform alarm timestamp is only a wake-up hint; logical event identity comes
 * from persisted `{ tag, id }` rows.
 *
 * Retry safety depends on acknowledgement ordering. `processDueAlarms` runs the
 * caller's handler first and only then conditionally deletes or advances the
 * same selected row. By default, handler failures are isolated: the failed row
 * is retried after a delay, later due rows continue, and the platform alarm is
 * reconciled once at the end. Use `mode: "ordered"` for strict workflows where
 * one failed logical alarm should block later due alarms.
 *
 * Provide `DurableObjectAlarm.layer` anywhere `DurableObjectState` is available.
 *
 * @example Providing the service
 * ```ts
 * const program = Effect.gen(function* () {
 *   const durableObjectAlarm = yield* DurableObjectAlarm;
 *   const now = yield* DateTime.now;
 *
 *   yield* durableObjectAlarm.scheduleAlarm({
 *     tag: "heartbeat",
 *     id: "heartbeat-check",
 *     runAt: DateTime.add(now, { seconds: 5 }),
 *     repeatEvery: Duration.seconds(5),
 *     payload: null,
 *   });
 * }).pipe(Effect.provide(DurableObjectAlarm.layer));
 * ```
 *
 * @example Processing due alarms
 * ```ts
 * const handledEvents = yield* durableObjectAlarm.processDueAlarms((event) =>
 *   Effect.gen(function* () {
 *     if (event.tag === "heartbeat") {
 *       yield* heartbeatManager.handleAlarmEvent(event);
 *     }
 *   })
 * );
 * ```
 */
declare class DurableObjectAlarm extends DurableObjectAlarm_base {
  static readonly layer: Layer.Layer<DurableObjectAlarm, never, DurableObjectState>;
}
declare namespace DurableObjectRpcWebSocket_d_exports {
  export { DurableObjectRpcWebSocket, DurableObjectRpcWebSocketService, LayerOptions$7 as LayerOptions, NativeWebSocketMessage, layer$7 as layer };
}
/**
 * Configuration for {@link layer}.
 */
interface LayerOptions$7 {
  /** Tag used to select hibernated sockets. */
  readonly tag?: string | undefined;
  /** Socket attachment key used to persist client ids across hibernation. */
  readonly attachmentKey?: string | undefined;
}
/** Native websocket event payload accepted by Cloudflare Durable Objects. */
type NativeWebSocketMessage = string | ArrayBuffer;
/**
 * Service API used to wire websocket lifecycle events to Effect RPC server protocol.
 */
interface DurableObjectRpcWebSocketService {
  readonly accept: (socket: DurableWebSocket) => Effect.Effect<void>;
  readonly message: (socket: DurableWebSocket, message: NativeWebSocketMessage) => Effect.Effect<void>;
  readonly close: (socket: DurableWebSocket) => Effect.Effect<void>;
  readonly error: (socket: DurableWebSocket, error: unknown) => Effect.Effect<void>;
}
declare const DurableObjectRpcWebSocket_base: Context.ServiceClass<DurableObjectRpcWebSocket, "effect-cf/DurableObjectRpcWebSocket", DurableObjectRpcWebSocketService>;
/**
 * Context tag for the Durable Object RPC websocket service.
 */
declare class DurableObjectRpcWebSocket extends DurableObjectRpcWebSocket_base {}
/**
 * Builds a layer that bridges Durable Object websocket events to `RpcServer.Protocol`.
 */
declare const layer$7: (options?: LayerOptions$7) => Layer.Layer<DurableObjectRpcWebSocket | RpcServer.Protocol, never, DurableObjectState | RpcSerialization.RpcSerialization>;
declare namespace DurableObjectSqlite_d_exports {
  export { SqliteLayerOptions, layer$6 as layer };
}
/** Options forwarded to `@effect/sql-sqlite-do` when building a SQL client layer. */
type SqliteLayerOptions = Omit<SqliteClient.SqliteClientConfig, "db">;
/**
 * Provides `effect/unstable/sql` from the current Durable Object SQLite storage.
 *
 * @example
 * ```ts
 * const RoomLayer = Layer.mergeAll(
 *   DurableObjectSqlite.layer(),
 *   OtherRoomServices,
 * );
 * ```
 */
declare const layer$6: (options?: SqliteLayerOptions) => Layer.Layer<_$effect_unstable_sql_SqlClient0.SqlClient | SqliteClient.SqliteClient, never, DurableObjectState>;
declare namespace Email_d_exports {
  export { EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailMessage, EmailMessageBuilder, EmailOperationError, EmailSendInput, EmailSendResult, EmailService, LayerOptions$6 as LayerOptions, Tag$7 as Tag, TagClass$6 as TagClass, isEmailBinding, layer$5 as layer, make$5 as make, makeClient$5 as makeClient };
}
declare const EmailOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "EmailOperationError";
} & Readonly<A>;
/** Error raised when a Cloudflare Send Email operation fails. */
declare class EmailOperationError extends EmailOperationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly cause: unknown;
}> {}
/** Typed Cloudflare Send Email binding definition. */
interface EmailDefinition {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
}
type EmailAddress = CloudflareEmailAddress;
type EmailAttachment = CloudflareEmailAttachment;
type EmailMessage = CloudflareEmailMessage;
type EmailMessageBuilder = Parameters<CloudflareSendEmail["send"]>[0];
type EmailSendInput = EmailMessage | EmailMessageBuilder;
type EmailSendResult = CloudflareEmailSendResult;
type EmailBinding = CloudflareSendEmail;
interface EmailClient {
  readonly send: {
    (message: EmailMessage): Effect.Effect<EmailSendResult, EmailOperationError>;
    (builder: EmailMessageBuilder): Effect.Effect<EmailSendResult, EmailOperationError>;
  };
  readonly unsafeRaw: Effect.Effect<EmailBinding>;
  readonly definition: EmailDefinition;
}
declare const EmailServiceTypeId: unique symbol;
/** Nominal service marker for Send Email services created with {@link make}. */
interface EmailService<Id extends string> {
  readonly [EmailServiceTypeId]: {
    readonly id: Id;
  };
}
type LayerOptions$6 = {
  readonly binding: string;
};
interface TagClass$6<Self, Id extends string> extends Context.ServiceClass<Self, Id, EmailClient> {
  readonly id: Id;
  readonly layer: (options: LayerOptions$6) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
}
declare const isEmailBinding: (value: unknown) => value is EmailBinding;
declare const makeClient$5: (definition: EmailDefinition) => (email: EmailBinding) => EmailClient;
declare const layer$5: <Self>(tag: Context.Service<Self, EmailClient>, definition: EmailDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare const make$5: <Id extends string>(id: Id) => TagClass$6<EmailService<Id>, Id>;
declare const Tag$7: <Self>() => <Id extends string>(id: Id) => TagClass$6<Self, Id>;
declare namespace Images_d_exports {
  export { DrawStepOptions, HostedImagesClient, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions$5 as LayerOptions, ProcessOptions, Step, Steps, Tag$6 as Tag, TagClass$5 as TagClass, draw, empty, isImagesBinding, layer$4 as layer, make$4 as make, makeClient$4 as makeClient, transform };
}
declare const TypeId: "effect-cf/Images/Steps";
declare const ImagesOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "ImagesOperationError";
} & Readonly<A>;
/** Error raised when a Cloudflare Images operation fails. */
declare class ImagesOperationError extends ImagesOperationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly cause: unknown;
}> {}
/** Typed Cloudflare Images binding definition. */
interface ImagesDefinition {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
}
type ImageInfoResponse = CloudflareImageInfoResponse;
type ImageTransform = CloudflareImageTransform;
type ImageDrawOptions = CloudflareImageDrawOptions;
type ImageInputOptions = CloudflareImageInputOptions;
type ImageOutputOptions = CloudflareImageOutputOptions;
type ImageTransformationOutputOptions = CloudflareImageTransformationOutputOptions;
type ImageTransformationResult = CloudflareImageTransformationResult;
type ImageUploadOptions = CloudflareImageUploadOptions;
type ImageUpdateOptions = CloudflareImageUpdateOptions;
type ImageListOptions = CloudflareImageListOptions;
type ImageList = CloudflareImageList;
type ImageMetadata = CloudflareImageMetadata;
type ImageInputValue = ReadableStream<Uint8Array> | ArrayBuffer;
type ImageUploadValue = ReadableStream<Uint8Array> | ArrayBuffer;
interface DrawStepOptions {
  readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
  readonly options?: ImageDrawOptions;
}
type Step = Data.TaggedEnum<{
  readonly Transform: {
    readonly transform: ImageTransform;
  };
  readonly Draw: DrawStepOptions;
}>;
interface Steps {
  readonly [TypeId]: typeof TypeId;
  readonly steps: ReadonlyArray<Step>;
}
interface ProcessOptions {
  readonly stream: ImageInputValue;
  readonly inputOptions?: ImageInputOptions;
  readonly outputOptions: ImageOutputOptions;
}
interface ImagesTransformationResultClient {
  readonly raw: CloudflareImageTransformationResult;
  readonly response: Effect.Effect<CloudflareResponse, ImagesOperationError>;
  readonly contentType: Effect.Effect<string, ImagesOperationError>;
  readonly image: (options?: ImageTransformationOutputOptions) => Effect.Effect<ReadableStream<Uint8Array>, ImagesOperationError>;
}
interface ImageHandleClient {
  readonly raw: CloudflareImageHandle;
  readonly details: Effect.Effect<Option.Option<ImageMetadata>, ImagesOperationError>;
  readonly bytes: Effect.Effect<Option.Option<ReadableStream<Uint8Array>>, ImagesOperationError>;
  readonly update: (options: ImageUpdateOptions) => Effect.Effect<ImageMetadata, ImagesOperationError>;
  readonly delete: Effect.Effect<boolean, ImagesOperationError>;
}
interface HostedImagesClient {
  readonly image: (imageId: string) => ImageHandleClient;
  readonly upload: (image: ImageUploadValue, options?: ImageUploadOptions) => Effect.Effect<ImageMetadata, ImagesOperationError>;
  readonly list: (options?: ImageListOptions) => Effect.Effect<ImageList, ImagesOperationError>;
  readonly unsafeRaw: Effect.Effect<CloudflareHostedImagesBinding>;
}
interface ImagesRuntimeBinding {
  readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Promise<ImageInfoResponse>;
  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => CloudflareImageTransformer;
  readonly hosted?: CloudflareHostedImagesBinding;
}
interface ImagesClient {
  readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<ImageInfoResponse, ImagesOperationError>;
  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<CloudflareImageTransformer, ImagesOperationError>;
  readonly process: (steps: Steps, options: ProcessOptions) => Effect.Effect<ImagesTransformationResultClient, ImagesOperationError>;
  readonly hosted: Option.Option<HostedImagesClient>;
  readonly unsafeRaw: Effect.Effect<ImagesRuntimeBinding>;
  readonly definition: ImagesDefinition;
}
declare const ImagesServiceTypeId: unique symbol;
/** Nominal service marker for Images services created with {@link make}. */
interface ImagesService<Id extends string> {
  readonly [ImagesServiceTypeId]: {
    readonly id: Id;
  };
}
type LayerOptions$5 = {
  readonly binding: string;
};
interface TagClass$5<Self, Id extends string> extends Context.ServiceClass<Self, Id, ImagesClient> {
  readonly id: Id;
  readonly layer: (options: LayerOptions$5) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
}
/** Empty Images transformation pipeline. */
declare const empty: Steps;
declare function transform(transform: ImageTransform): (steps: Steps) => Steps;
declare function transform(steps: Steps, transform: ImageTransform): Steps;
declare function draw(draw: DrawStepOptions): (steps: Steps) => Steps;
declare function draw(steps: Steps, draw: DrawStepOptions): Steps;
declare const isImagesBinding: (value: unknown) => value is ImagesRuntimeBinding;
declare const makeClient$4: (definition: ImagesDefinition) => (images: ImagesRuntimeBinding) => ImagesClient;
declare const layer$4: <Self>(tag: Context.Service<Self, ImagesClient>, definition: ImagesDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare const make$4: <Id extends string>(id: Id) => TagClass$5<ImagesService<Id>, Id>;
declare const Tag$6: <Self>() => <Id extends string>(id: Id) => TagClass$5<Self, Id>;
declare namespace Kv_d_exports {
  export { Definition$2 as Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions$4 as LayerOptions, Tag$5 as Tag, TagClass$4 as TagClass, isKvNamespace, layer$3 as layer, makeClient$3 as makeClient };
}
declare const KvOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "KvOperationError";
} & Readonly<A>;
/** Error raised when a KV operation fails. */
declare class KvOperationError extends KvOperationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly cause: unknown;
}> {}
/** `KVNamespace.put` options. */
type KvPutOptions = CloudflareKVNamespacePutOptions;
/** `KVNamespace.list` options with optional metadata decoding schema. */
type KvListOptions<Metadata = unknown> = CloudflareKVNamespaceListOptions & {
  readonly metadataSchema?: Schema.Codec<Metadata, unknown>;
};
/** Successful value returned by `getWithMetadata`. */
interface KvWithMetadata<Value, Metadata> {
  readonly value: Value;
  readonly metadata: Option.Option<Metadata>;
  readonly cacheStatus: Option.Option<string>;
}
/** Decoded key entry returned by `list`. */
interface KvListKey<Key, Metadata = unknown> {
  readonly name: Key;
  readonly expiration: Option.Option<number>;
  readonly metadata: Option.Option<Metadata>;
}
/** Decoded result returned by `list`. */
interface KvListResult<Key, Metadata = unknown> {
  readonly keys: ReadonlyArray<KvListKey<Key, Metadata>>;
  readonly listComplete: boolean;
  readonly cursor: Option.Option<string>;
  readonly cacheStatus: Option.Option<string>;
}
/**
 * Typed KV binding definition.
 */
interface KvDefinition<Key, Value, EncodedValue> {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
  /** Codec used to encode/decode keys. */
  readonly key: Schema.Codec<Key, string>;
  /** Codec used to encode/decode values. */
  readonly value: Schema.Codec<Value, EncodedValue>;
}
/**
 * Reusable typed KV resource definition without a concrete Cloudflare binding name.
 */
interface Definition$2<Id extends string = string, Key = unknown, Value = unknown, EncodedValue = unknown> {
  readonly id: Id;
  /** Codec used to encode/decode keys. */
  readonly key: Schema.Codec<Key, string>;
  /** Codec used to encode/decode values. */
  readonly value: Schema.Codec<Value, EncodedValue>;
}
declare namespace Definition$2 {
  type Any = Definition$2<string, any, any, any>;
}
interface KvClient<Key, Value, EncodedValue> {
  readonly put: (key: Key, value: Value, options?: KvPutOptions) => Effect.Effect<void, KvOperationError | Schema.SchemaError>;
  readonly get: (key: Key) => Effect.Effect<Option.Option<Value>, KvOperationError | Schema.SchemaError>;
  readonly getWithMetadata: <Metadata>(key: Key, metadataSchema: Schema.Codec<Metadata, unknown>) => Effect.Effect<Option.Option<KvWithMetadata<Value, Metadata>>, KvOperationError | Schema.SchemaError>;
  readonly list: <Metadata = unknown>(options?: KvListOptions<Metadata>) => Effect.Effect<KvListResult<Key, Metadata>, KvOperationError | Schema.SchemaError>;
  readonly remove: (key: Key) => Effect.Effect<void, KvOperationError | Schema.SchemaError>;
  readonly unsafeRaw: Effect.Effect<KVNamespace>;
  readonly definition: KvDefinition<Key, Value, EncodedValue>;
}
type LayerOptions$4 = {
  readonly binding: string;
};
interface TagClass$4<Self, Id extends string, Key, Value, EncodedValue> extends Context.ServiceClass<Self, Id, KvClient<Key, Value, EncodedValue>> {
  readonly id: Id;
  readonly keySchema: Schema.Codec<Key, string>;
  readonly valueSchema: Schema.Codec<Value, EncodedValue>;
  readonly layer: (options: LayerOptions$4) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
}
declare const isKvNamespace: (value: unknown) => value is KVNamespace;
declare const makeClient$3: <Key, Value, EncodedValue>(definition: KvDefinition<Key, Value, EncodedValue>) => ((kv: KVNamespace) => KvClient<Key, Value, EncodedValue>);
declare const layer$3: <Self, Key, Value, EncodedValue>(tag: Context.Service<Self, KvClient<Key, Value, EncodedValue>>, definition: KvDefinition<Key, Value, EncodedValue>) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare const Tag$5: <Self>() => <Id extends string, Key, Value, EncodedValue>(id: Id, definition: {
  readonly key: Schema.Codec<Key, string>;
  readonly value: Schema.Codec<Value, EncodedValue>;
}) => TagClass$4<Self, Id, Key, Value, EncodedValue>;
declare namespace R2_d_exports {
  export { LayerOptions$3 as LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag$4 as Tag, TagClass$3 as TagClass, isR2Bucket, layer$2 as layer, make$3 as make, makeClient$2 as makeClient };
}
declare const R2OperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "R2OperationError";
} & Readonly<A>;
/** Error raised when an R2 operation fails. */
declare class R2OperationError extends R2OperationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly cause: unknown;
}> {}
/** Typed R2 bucket binding definition. */
interface R2Definition {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
}
type R2GetOptions = CloudflareR2GetOptions;
type R2PutOptions = CloudflareR2PutOptions;
type R2ListOptions = CloudflareR2ListOptions;
type R2MultipartOptions = CloudflareR2MultipartOptions;
type R2UploadPartOptions = CloudflareR2UploadPartOptions;
type R2PutValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob;
type R2UploadPartValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
interface R2ObjectBodyClient extends Omit<CloudflareR2ObjectBody, "arrayBuffer" | "blob" | "bytes" | "json" | "text"> {
  readonly raw: CloudflareR2ObjectBody;
  readonly arrayBuffer: Effect.Effect<ArrayBuffer, R2OperationError>;
  readonly bytes: Effect.Effect<Uint8Array, R2OperationError>;
  readonly text: Effect.Effect<string, R2OperationError>;
  readonly json: <T = unknown>() => Effect.Effect<T, R2OperationError>;
  readonly blob: Effect.Effect<Blob, R2OperationError>;
}
interface R2MultipartUploadClient {
  readonly raw: CloudflareR2MultipartUpload;
  readonly key: string;
  readonly uploadId: string;
  readonly uploadPart: (partNumber: number, value: R2UploadPartValue, options?: R2UploadPartOptions) => Effect.Effect<CloudflareR2UploadedPart, R2OperationError>;
  readonly abort: Effect.Effect<void, R2OperationError>;
  readonly complete: (uploadedParts: ReadonlyArray<CloudflareR2UploadedPart>) => Effect.Effect<CloudflareR2Object, R2OperationError>;
}
interface R2Client {
  readonly head: (key: string) => Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
  readonly get: {
    (key: string, options: R2GetOptions & {
      readonly onlyIf: CloudflareR2Conditional | Headers;
    }): Effect.Effect<Option.Option<R2ObjectBodyClient | CloudflareR2Object>, R2OperationError>;
    (key: string, options?: R2GetOptions): Effect.Effect<Option.Option<R2ObjectBodyClient>, R2OperationError>;
  };
  readonly put: {
    (key: string, value: R2PutValue, options: R2PutOptions & {
      readonly onlyIf: CloudflareR2Conditional | Headers;
    }): Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
    (key: string, value: R2PutValue, options?: R2PutOptions): Effect.Effect<CloudflareR2Object, R2OperationError>;
  };
  readonly createMultipartUpload: (key: string, options?: R2MultipartOptions) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
  readonly resumeMultipartUpload: (key: string, uploadId: string) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
  readonly delete: (keys: string | ReadonlyArray<string>) => Effect.Effect<void, R2OperationError>;
  readonly list: (options?: R2ListOptions) => Effect.Effect<CloudflareR2Objects, R2OperationError>;
  readonly unsafeRaw: Effect.Effect<CloudflareR2Bucket>;
  readonly definition: R2Definition;
}
declare const R2ServiceTypeId: unique symbol;
/** Nominal service marker for R2 services created with {@link make}. */
interface R2Service<Id extends string> {
  readonly [R2ServiceTypeId]: {
    readonly id: Id;
  };
}
type LayerOptions$3 = {
  readonly binding: string;
};
interface TagClass$3<Self, Id extends string> extends Context.ServiceClass<Self, Id, R2Client> {
  readonly id: Id;
  readonly layer: (options: LayerOptions$3) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
}
declare const isR2Bucket: (value: unknown) => value is CloudflareR2Bucket;
declare const makeClient$2: (definition: R2Definition) => ((bucket: CloudflareR2Bucket) => R2Client);
declare const layer$2: <Self>(tag: Context.Service<Self, R2Client>, definition: R2Definition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare const make$3: <Id extends string>(id: Id) => TagClass$3<R2Service<Id>, Id>;
declare const Tag$4: <Self>() => <Id extends string>(id: Id) => TagClass$3<Self, Id>;
declare namespace WorkflowBinding_d_exports {
  export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer$1 as layer, makeClient$1 as makeClient };
}
type WorkflowInstanceCreateOptions<Payload> = Omit<CloudflareWorkflowInstanceCreateOptions<Payload>, "params">;
type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown> = ReadonlyArray<{
  readonly payload: Payload;
} & WorkflowInstanceCreateOptions<EncodedPayload>>;
interface WorkflowInstanceRestartOptions {
  readonly from?: {
    readonly name?: string;
    readonly count?: number;
    readonly type?: string;
  };
}
type WorkflowInstanceStatusName = CloudflareInstanceStatus["status"];
interface WorkflowInstanceStatus<Result> {
  readonly status: WorkflowInstanceStatusName;
  readonly output: Option.Option<Result>;
  readonly error: Option.Option<{
    readonly name: string;
    readonly message: string;
  }>;
}
interface WorkflowInstance<Result> {
  readonly raw: CloudflareWorkflowInstance;
  readonly id: string;
  readonly pause: Effect.Effect<void, WorkflowOperationError>;
  readonly resume: Effect.Effect<void, WorkflowOperationError>;
  readonly terminate: Effect.Effect<void, WorkflowOperationError>;
  readonly restart: (options?: WorkflowInstanceRestartOptions) => Effect.Effect<void, WorkflowOperationError>;
  readonly status: Effect.Effect<WorkflowInstanceStatus<Result>, WorkflowOperationError | WorkflowResultDecodeError>;
  readonly sendEvent: (event: WorkflowInstanceEvent) => Effect.Effect<void, WorkflowOperationError>;
}
interface WorkflowInstanceEvent {
  readonly type: string;
  readonly payload: unknown;
}
interface WorkflowBindingDefinition<Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4> {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
  /** Codec used to encode payloads passed to `Workflow.create`. */
  readonly payload: Payload;
  /** Codec used to decode completed workflow status output. */
  readonly result: Result;
}
interface WorkflowBindingClient<Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4> {
  readonly create: (payload: Schema.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions<Schema.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError | Schema.SchemaError>;
  readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<Schema.Schema.Type<Payload>, Schema.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<Schema.Schema.Type<Result>>>, WorkflowOperationError | Schema.SchemaError>;
  readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError>;
  readonly unsafeRaw: Effect.Effect<CloudflareWorkflow<Schema.Codec.Encoded<Payload>>>;
}
declare const WorkflowOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "WorkflowOperationError";
} & Readonly<A>;
declare class WorkflowOperationError extends WorkflowOperationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly cause: unknown;
}> {}
declare const WorkflowResultDecodeError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "WorkflowResultDecodeError";
} & Readonly<A>;
declare class WorkflowResultDecodeError extends WorkflowResultDecodeError_base<{
  readonly binding: string;
  readonly instanceId: string;
  readonly cause: unknown;
}> {}
declare const isWorkflow: <Payload>(value: unknown) => value is CloudflareWorkflow<Payload>;
declare const makeClient$1: <Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(definition: WorkflowBindingDefinition<Payload, Result>) => ((workflow: CloudflareWorkflow<Schema.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>);
declare const layer$1: <Self, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(tag: Context.Service<Self, WorkflowBindingClient<Payload, Result>>, definition: WorkflowBindingDefinition<Payload, Result>) => _$effect_Layer0.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare namespace WorkflowDefinition_d_exports {
  export { Definition$1 as Definition, Handler$1 as Handler, LayerOptions$2 as LayerOptions, Options$1 as Options, Tag$3 as Tag, TagClass$2 as TagClass, Workflow, implement$1 as implement, make$2 as make };
}
interface Definition$1<Id extends string = string, Payload extends ServiceFreeSchema$4 = ServiceFreeSchema$4, Result extends ServiceFreeSchema$4 = ServiceFreeSchema$4> {
  readonly id: Id;
  readonly payload: Payload;
  readonly result: Result;
}
declare namespace Definition$1 {
  type Any = Definition$1<string, ServiceFreeSchema$4, ServiceFreeSchema$4>;
}
type Handler$1<ROut, Self extends Definition$1.Any> = (payload: Schema.Schema.Type<Self["payload"]>) => Effect.Effect<Schema.Schema.Type<Self["result"]>, unknown, WorkflowRunContext<ROut>>;
interface Options$1<ROut, Self extends Definition$1.Any> {
  readonly run: Handler$1<ROut, Self>;
}
type LayerOptions$2 = {
  readonly binding: string;
};
interface TagClass$2<Self, Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4> extends Context.ServiceClass<Self, Id, WorkflowBindingClient<Payload, Result>> {
  readonly id: Id;
  readonly payload: Payload;
  readonly result: Result;
  readonly make: <ROut, LayerError>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: Options$1<ROut, Definition$1<Id, Payload, Result>>) => WorkflowClass<Schema.Codec.Encoded<Payload>, Schema.Codec.Encoded<Result>, ROut>;
  readonly layer: (options: LayerOptions$2) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
  readonly create: (payload: Schema.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions<Schema.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError | Schema.SchemaError, Self>;
  readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<Schema.Schema.Type<Payload>, Schema.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<Schema.Schema.Type<Result>>>, WorkflowOperationError | Schema.SchemaError, Self>;
  readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<Schema.Schema.Type<Result>>, WorkflowOperationError, Self>;
  readonly unsafeRaw: () => Effect.Effect<globalThis.Workflow<Schema.Codec.Encoded<Payload>>, never, Self>;
}
declare const make$2: <Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(id: Id, definition: {
  readonly payload: Payload;
  readonly result: Result;
}) => TagClass$2<Definition$1<Id, Payload, Result>, Id, Payload, Result>;
declare const Tag$3: <Self>() => <Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(id: Id, definition: {
  readonly payload: Payload;
  readonly result: Result;
}) => TagClass$2<Self, Id, Payload, Result>;
declare const Workflow: <Self>() => <Id extends string, Payload extends ServiceFreeSchema$4, Result extends ServiceFreeSchema$4>(id: Id, definition: {
  readonly payload: Payload;
  readonly result: Result;
}) => TagClass$2<Self, Id, Payload, Result>;
declare const implement$1: <ROut, const Self extends Definition$1.Any>(_definition: Self, handler: Handler$1<ROut, Self>) => Handler$1<ROut, Self>;
declare namespace Workflow_d_exports {
  export { Definition, Handler, LayerOptions$1 as LayerOptions, Options, Tag$2 as Tag, TagClass$1 as TagClass, WorkflowClass, WorkflowEvent$1 as WorkflowEvent, WorkflowEventService, WorkflowHandler, WorkflowOptions, WorkflowRunContext, WorkflowStep$1 as WorkflowStep, WorkflowStepContext$1 as WorkflowStepContext, WorkflowStepService, implement, make$1 as make, sleep, sleepUntil, step, waitForEvent };
}
interface WorkflowEventService<Payload = unknown> {
  readonly raw: WorkflowEvent<unknown>;
  readonly payload: Payload;
  readonly timestamp: Date;
  readonly instanceId: string;
  readonly workflowName: string;
}
declare const WorkflowEvent_base: Context.ServiceClass<WorkflowEvent$1, "effect-cf/WorkflowEvent", WorkflowEventService<unknown>>;
declare class WorkflowEvent$1 extends WorkflowEvent_base {}
interface WorkflowStepService {
  readonly raw: WorkflowStep;
  do<A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig): Effect.Effect<A, unknown, Exclude<R, WorkflowStepContext$1>>;
  readonly sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, unknown>;
  readonly sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, unknown>;
  readonly waitForEvent: <Payload>(name: string, options: {
    readonly type: string;
    readonly timeout?: WorkflowTimeoutDuration | number;
  }) => Effect.Effect<WorkflowStepEvent<Payload>, unknown>;
}
declare const WorkflowStep_base: Context.ServiceClass<WorkflowStep$1, "effect-cf/WorkflowStep", WorkflowStepService>;
declare class WorkflowStep$1 extends WorkflowStep_base {}
declare const WorkflowStepContext_base: Context.ServiceClass<WorkflowStepContext$1, "effect-cf/WorkflowStepContext", WorkflowStepContext>;
declare class WorkflowStepContext$1 extends WorkflowStepContext_base {}
type RuntimeContext<ROut> = ExecutionContext | WorkerContext | WorkerEnvironment | ROut;
type WorkflowRunContext<ROut> = RuntimeContext<ROut> | WorkflowEvent$1 | WorkflowStep$1 | Scope.Scope;
type WorkflowHandler<ROut, Payload = unknown, Result = unknown> = (payload: Payload) => Effect.Effect<Result, unknown, WorkflowRunContext<ROut>>;
interface WorkflowOptions<ROut, Payload = unknown, Result = unknown> {
  readonly run: WorkflowHandler<ROut, Payload, Result>;
}
type WorkflowClass<Payload, Result, _ROut> = new (ctx: globalThis.ExecutionContext, env: WorkerEnv) => WorkflowEntrypoint<WorkerEnv, Payload> & {
  run(event: Readonly<WorkflowEvent<Payload>>, step: WorkflowStep): Promise<Result>;
};
declare const make$1: <ROut, LayerError, Payload = unknown, Result = unknown>(layer: Layer.Layer<ROut, LayerError, ExecutionContext | WorkerContext | WorkerEnvironment>, options: WorkflowOptions<ROut, Payload, Result>) => WorkflowClass<Payload, Result, ROut>;
declare const step: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>, config?: WorkflowStepConfig) => Effect.Effect<A, unknown, WorkflowStep$1 | Exclude<R, WorkflowStepContext$1>>;
declare const sleep: (name: string, duration: WorkflowSleepDuration) => Effect.Effect<void, unknown, WorkflowStep$1>;
declare const sleepUntil: (name: string, timestamp: Date | number) => Effect.Effect<void, unknown, WorkflowStep$1>;
declare const waitForEvent: <Payload>(name: string, options: {
  readonly type: string;
  readonly timeout?: WorkflowTimeoutDuration | number;
}) => Effect.Effect<WorkflowStepEvent<Payload>, unknown, WorkflowStep$1>;
type Definition<Id extends string = string, Payload extends Definition$1.Any["payload"] = Definition$1.Any["payload"], Result extends Definition$1.Any["result"] = Definition$1.Any["result"]> = Definition$1<Id, Payload, Result>;
declare namespace Definition {
  type Any = Definition$1.Any;
}
type LayerOptions$1 = LayerOptions$2;
type TagClass$1<Self, Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]> = TagClass$2<Self, Id, Payload, Result>;
declare const Tag$2: <Self>() => <Id extends string, Payload extends Definition$1.Any["payload"], Result extends Definition$1.Any["result"]>(id: Id, definition: {
  readonly payload: Payload;
  readonly result: Result;
}) => TagClass$1<Self, Id, Payload, Result>;
declare const implement: <ROut, const Self extends Definition$1.Any>(_definition: Self, handler: Handler$1<ROut, Self>) => Handler$1<ROut, Self>;
type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
declare namespace Vectorize_d_exports {
  export { LayerOptions, Tag$1 as Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make, makeClient };
}
declare const VectorizeOperationError_base: new <A extends Record<string, any> = {}>(args: _$effect_Types0.VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }>) => _$effect_Cause0.YieldableError & {
  readonly _tag: "VectorizeOperationError";
} & Readonly<A>;
/** Error raised when a Vectorize operation fails. */
declare class VectorizeOperationError extends VectorizeOperationError_base<{
  readonly binding: string;
  readonly operation: string;
  readonly cause: unknown;
}> {}
/** Typed Vectorize binding definition. */
interface VectorizeDefinition {
  /** Binding name as configured in `wrangler.jsonc`. */
  readonly binding: string;
}
type VectorizeBinding = CloudflareVectorize | CloudflareVectorizeIndex;
type VectorizeVector = CloudflareVectorizeVector;
type VectorizeVectorMetadata = CloudflareVectorizeVectorMetadata;
type VectorizeVectorMetadataValue = CloudflareVectorizeVectorMetadataValue;
type VectorizeVectorMetadataFilter = CloudflareVectorizeVectorMetadataFilter;
type VectorizeQueryOptions = CloudflareVectorizeQueryOptions;
type VectorizeMatches = CloudflareVectorizeMatches;
type VectorizeMatch = CloudflareVectorizeMatch;
type VectorizeIndexInfo = CloudflareVectorizeIndexInfo;
type VectorizeIndexDetails = CloudflareVectorizeIndexDetails;
type VectorizeMutation = CloudflareVectorizeAsyncMutation | CloudflareVectorizeVectorMutation;
type VectorizeValues = Float32Array | Float64Array | ReadonlyArray<number>;
interface VectorizeClient {
  readonly describe: Effect.Effect<VectorizeIndexInfo | VectorizeIndexDetails, VectorizeOperationError>;
  readonly query: (vector: VectorizeValues, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
  readonly queryById: (vectorId: string, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
  readonly insert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
  readonly upsert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
  readonly deleteByIds: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
  readonly delete: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
  readonly getByIds: (ids: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<VectorizeVector>, VectorizeOperationError>;
  readonly unsafeRaw: Effect.Effect<VectorizeBinding>;
  readonly definition: VectorizeDefinition;
}
declare const VectorizeServiceTypeId: unique symbol;
/** Nominal service marker for Vectorize services created with {@link make}. */
interface VectorizeService<Id extends string> {
  readonly [VectorizeServiceTypeId]: {
    readonly id: Id;
  };
}
type LayerOptions = {
  readonly binding: string;
};
interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, VectorizeClient> {
  readonly id: Id;
  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
}
declare const isVectorizeBinding: (value: unknown) => value is VectorizeBinding;
declare const makeClient: (definition: VectorizeDefinition) => (index: VectorizeBinding) => VectorizeClient;
declare const layer: <Self>(tag: Context.Service<Self, VectorizeClient>, definition: VectorizeDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
declare const make: <Id extends string>(id: Id) => TagClass<VectorizeService<Id>, Id>;
declare const Tag$1: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
//#endregion
export { AiGateway_d_exports as AiGateway, AnalyticsEngine_d_exports as AnalyticsEngine, Binding_d_exports as Binding, BrowserRendering_d_exports as BrowserRendering, CloudflareOtlp_d_exports as CloudflareOtlp, D1_d_exports as D1, DurableObject_d_exports as DurableObject, DurableObjectAlarm_d_exports as DurableObjectAlarm, DurableObjectDefinition_d_exports as DurableObjectDefinition, DurableObjectNamespace_d_exports as DurableObjectNamespace, DurableObjectRpcWebSocket_d_exports as DurableObjectRpcWebSocket, DurableObjectSqlite_d_exports as DurableObjectSqlite, DurableObjectState_d_exports as DurableObjectState, DurableObjectStorage_d_exports as DurableObjectStorage, DurableObjectWebSocket_d_exports as DurableObjectWebSocket, Email_d_exports as Email, Hyperdrive_d_exports as Hyperdrive, Images_d_exports as Images, Kv_d_exports as Kv, Queue_d_exports as Queue, QueueBinding_d_exports as QueueBinding, QueueDefinition_d_exports as QueueDefinition, R2_d_exports as R2, Rpc_d_exports as Rpc, RpcDefinition_d_exports as RpcDefinition, ServiceBinding_d_exports as ServiceBinding, Vectorize_d_exports as Vectorize, Worker_d_exports as Worker, WorkerConfig, WorkerDefinition_d_exports as WorkerDefinition, type WorkerEnv, WorkerEnvironment, WorkersAi_d_exports as WorkersAi, Workflow_d_exports as Workflow, WorkflowBinding_d_exports as WorkflowBinding, WorkflowDefinition_d_exports as WorkflowDefinition };