effect-cf 0.39.1 → 0.40.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # effect-cf
 
+## 0.40.1
+
+### Patch Changes
+
+- [#151](https://github.com/danieljvdm/effect-cf/pull/151) [`f6c9c9f`](https://github.com/danieljvdm/effect-cf/commit/f6c9c9f8ff504d44ab9c5c0d0fa6fc4c47a98039) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Reduce consumer bundles by preserving module boundaries in the published package and avoiding unused telemetry exporters. Consumers using only KV no longer retain unrelated Workers, Workflows, or Node async-hooks imports.
+
+- [#153](https://github.com/danieljvdm/effect-cf/pull/153) [`00a1247`](https://github.com/danieljvdm/effect-cf/commit/00a1247cfff4641539ffdb3928b56e4887e32499) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Reduce unused Effect code retained by consumer bundlers such as Wrangler and esbuild. Existing package imports and APIs continue to work without application changes.
+
+## 0.40.0
+
+### Minor Changes
+
+- [#146](https://github.com/danieljvdm/effect-cf/pull/146) [`376c9cc`](https://github.com/danieljvdm/effect-cf/commit/376c9ccb16c7ee6a3d6ac2c6f8d6c91ad0b237fc) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Add schema-bound scheduling, cancellation, and transactions through `DurableObjectAlarm.Tag`. Register the service's complete `handlers(...)` implementation in a Durable Object's `alarms:` option, then yield the service to schedule work. Missing registration or handlers fail typechecking. Scheduling checks tag/payload pairs and schema-encodes payloads before storage.
+
+  Durable Object entrypoints provide registered alarm services to application layers and handlers. The raw scheduler is provided automatically and remains available for dynamic tags; existing explicit layers and handler-only `define(...)` calls remain supported.
+
+  Unknown stored alarm tags now report `StoredAlarmDecodeError` and follow the delivery failure policy instead of being silently acknowledged. Applications intentionally retiring tags can handle them through `onFailure`.
+
 ## 0.39.1
 
 ### Patch Changes

package/README.md

@@ -45,10 +45,18 @@ const greeting = Effect.gen(function* () {
 
 Declare `SETTINGS` in `wrangler.jsonc` and pass `SettingsLive` to `Worker.make`. Other bindings use the same tag/layer pattern.
 
-The [counter example](https://github.com/danieljvdm/effect-cf/tree/main/examples/counter) shows `DurableObject.Tag`, storage, a typed RPC call, and the complete Wrangler configuration.
+The [document outbox example](https://github.com/danieljvdm/effect-cf/tree/main/examples/outbox) saves document revisions and their delivery alarms atomically, then archives them to R2 outside the transaction.
 
 For atomic application writes and alarm changes, see the [alarm transaction example](tests/fixtures/alarm-transaction-consumer.ts) and [API contract](src/DurableObjectAlarm.ts).
 
+Define a typed alarm service with `class Alarms extends DurableObjectAlarm.Tag<Alarms>()("Alarms", { ...schemas }) {}`. Pass `Alarms.handlers({ ...implementations })` to the DO's `alarms:` option, then `yield* Alarms` to schedule or cancel alarms and open transactions. All declared handlers are required. The registration provides the service to application layers, initialization, and event handlers; declaring schemas alone does not provide a scheduler.
+
+Scheduling accepts decoded payloads, encodes them with the declared schema, and checks that the result is JSON before storage. Transaction callbacks expose the same typed mutations and retain the raw scheduler's rollback and callback-lifetime rules.
+
+`DurableObject.make` and tagged definitions' `.make` still provide the raw `DurableObjectAlarm` service automatically for dynamic tags and JSON payloads. `DurableObjectAlarm.define({ ... }).handlers(...)` remains a handler-only helper for raw scheduling. No alarm tables or native alarms are created until the scheduler is used. Outside these entrypoints, provide the raw scheduler layer explicitly. A typed registration exposes `layer` and `run` for custom runtimes and tests; custom runtimes must install both.
+
+Unknown stored tags produce `StoredAlarmDecodeError` and follow the configured delivery failure policy rather than being acknowledged silently. Use the raw scheduler's `cancelAlarm` to remove retired tags, including repeating alarms.
+
 ## Cloudflare Observability traces
 
 `CloudflareTracer.layer` sends existing `Effect.withSpan` and named `Effect.fn`

package/dist/AiGateway.d.mts

@@ -0,0 +1,86 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import { WorkersAiBinding, isWorkersAiBinding } from "./WorkersAi.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import { Layer } from "effect";
+declare namespace AiGateway_d_exports {
+  export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, LayerOptions, Tag, TagClass, isAiGatewayBinding, layer, make, makeClient, makeClientFromAi, makeHttpClient };
+}
+declare const AiGatewayOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "AiGatewayOperationError";
+} & Readonly<A>;
+declare class AiGatewayOperationError extends AiGatewayOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+interface AiGatewayDefinition {
+  readonly binding: string;
+  readonly gatewayId: string;
+  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];
+type AiGatewayBindingCandidate = Parameters<typeof isWorkersAiBinding>[0];
+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 rawUnsafe: Effect.Effect<AiGatewayBinding, AiGatewayOperationError>;
+  readonly definition: AiGatewayDefinition;
+}
+declare const AiGatewayServiceTypeId: unique symbol;
+interface AiGatewayService<Id extends string> {
+  readonly [AiGatewayServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+  readonly gatewayId: string;
+  readonly accountId?: string;
+};
+interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self, Id, AiGatewayClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError | AiGatewayOperationError, WorkerEnvironment>;
+}
+declare const isAiGatewayBinding: (value: AiGatewayBindingCandidate) => value is WorkersAiBinding;
+declare const makeClient: (definition: AiGatewayDefinition, gateway: AiGatewayBinding) => {
+  definition: AiGatewayDefinition;
+  run: (data: import("@cloudflare/workers-types").AIGatewayUniversalRequest | readonly import("@cloudflare/workers-types").AIGatewayUniversalRequest[], options?: {
+    gateway?: import("@cloudflare/workers-types").UniversalGatewayOptions;
+    extraHeaders?: object;
+    signal?: import("@cloudflare/workers-types").AbortSignal;
+  } | undefined) => Effect.Effect<import("@cloudflare/workers-types").Response, AiGatewayOperationError, never>;
+  getUrl: (provider?: string | undefined) => Effect.Effect<string, AiGatewayOperationError, never>;
+  fetch: (options: AiGatewayFetchOptions) => Effect.Effect<Response, AiGatewayOperationError, never>;
+  patchLog: (logId: string, data: import("@cloudflare/workers-types").AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError, never>;
+  getLog: (logId: string) => Effect.Effect<import("@cloudflare/workers-types").AiGatewayLog, AiGatewayOperationError, never>;
+  rawUnsafe: 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: <Self>(tag: Context$1.Service<Self, AiGatewayClient>, definition: AiGatewayDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<AiGatewayService<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+//#endregion
+export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, AiGateway_d_exports, LayerOptions, Tag, TagClass, isAiGatewayBinding, layer, make, makeClient, makeClientFromAi, makeHttpClient };

package/dist/AiGateway.mjs

@@ -0,0 +1,178 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer as layer$1 } from "./Binding.mjs";
+import { causeMessage } from "./internal/ErrorMessage.mjs";
+import { isWorkersAiBinding } from "./WorkersAi.mjs";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+//#region src/AiGateway.ts
+var AiGateway_exports = /* @__PURE__ */ __exportAll({
+	AiGatewayOperationError: () => AiGatewayOperationError,
+	Tag: () => Tag,
+	isAiGatewayBinding: () => isAiGatewayBinding,
+	layer: () => layer,
+	make: () => make,
+	makeClient: () => makeClient,
+	makeClientFromAi: () => makeClientFromAi,
+	makeHttpClient: () => makeHttpClient
+});
+const expectedAiGatewayBinding = "Workers AI binding with gateway()";
+var AiGatewayOperationError = class extends Data.TaggedError("AiGatewayOperationError") {
+	get message() {
+		return `AI Gateway ${this.operation} failed for binding "${this.binding}": ${causeMessage(this.cause)}`;
+	}
+};
+const AiGatewayMetadata = S.Record(S.String, S.Union([
+	S.String,
+	S.Number,
+	S.Boolean,
+	S.Null
+]));
+const AiGatewayHttpMetadata = S.Union([AiGatewayMetadata, S.fromJsonString(AiGatewayMetadata)]);
+const AiGatewayLogResponse = S.Struct({
+	success: S.Literal(true),
+	result: S.Struct({
+		id: S.String,
+		provider: S.String,
+		model: S.String,
+		model_type: S.optional(S.String),
+		path: S.String,
+		duration: S.Number,
+		request_type: S.optional(S.String),
+		request_content_type: S.optional(S.String),
+		status_code: S.Number,
+		response_content_type: S.optional(S.String),
+		success: S.Boolean,
+		cached: S.Boolean,
+		tokens_in: S.optional(S.Number),
+		tokens_out: S.optional(S.Number),
+		metadata: S.optional(AiGatewayHttpMetadata),
+		step: S.optional(S.Number),
+		cost: S.optional(S.Number),
+		custom_cost: S.optional(S.Boolean),
+		request_size: S.Number,
+		request_head: S.optional(S.String),
+		request_head_complete: S.Boolean,
+		response_size: S.Number,
+		response_head: S.optional(S.String),
+		response_head_complete: S.Boolean,
+		created_at: S.DateFromString
+	})
+});
+const AiGatewayPatchLogResponse = S.Struct({
+	success: S.Literal(true),
+	result: S.Unknown
+});
+const decodeAiGatewayLogResponse = S.decodeUnknownPromise(AiGatewayLogResponse);
+const decodeAiGatewayPatchLogResponse = S.decodeUnknownPromise(AiGatewayPatchLogResponse);
+const aiGatewayError = (binding, operation, cause) => new AiGatewayOperationError({
+	binding,
+	operation,
+	cause
+});
+const tryAiGatewayPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => aiGatewayError(binding, operation, cause)
+});
+const mergeAbortSignals = (userSignal, signal) => userSignal === null || userSignal === void 0 ? signal : AbortSignal.any([userSignal, signal]);
+const tryAiGatewaySync = (binding, operation, evaluate) => Effect.try({
+	try: evaluate,
+	catch: (cause) => aiGatewayError(binding, operation, cause)
+});
+const providerUrl = (baseUrl, path = "") => {
+	const url = new URL(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
+	const normalizedPath = path.replace(/^\/+/, "");
+	return normalizedPath === "" ? url : new URL(normalizedPath, url);
+};
+const gatewayUrl = (definition) => `https://gateway.ai.cloudflare.com/v1/${definition.accountId}/${definition.gatewayId}/`;
+const ensureSuccessfulResponse = (response) => {
+	if (!response.ok) throw new Error(`AI Gateway HTTP request failed with status ${response.status}`);
+};
+const isAiGatewayBinding = (value) => isWorkersAiBinding(value);
+const makeClient = (definition, gateway) => ({
+	definition,
+	run: Effect.fn("AiGateway.run")((data, options) => tryAiGatewayPromise(definition.binding, "run", () => gateway.run(Array.isArray(data) ? [...data] : data, options))),
+	getUrl: Effect.fn("AiGateway.getUrl")((provider) => tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(provider))),
+	fetch: Effect.fn("AiGateway.fetch")(function* (options) {
+		const baseUrl = yield* tryAiGatewayPromise(definition.binding, "getUrl", () => gateway.getUrl(options.provider));
+		return yield* tryAiGatewayPromise(definition.binding, "fetch", (signal) => fetch(providerUrl(baseUrl, options.path).href, {
+			...options.init,
+			signal: mergeAbortSignals(options.init?.signal, signal)
+		}));
+	}),
+	patchLog: Effect.fn("AiGateway.patchLog")((logId, data) => tryAiGatewayPromise(definition.binding, "patchLog", () => gateway.patchLog(logId, data))),
+	getLog: Effect.fn("AiGateway.getLog")((logId) => tryAiGatewayPromise(definition.binding, "getLog", () => gateway.getLog(logId))),
+	rawUnsafe: Effect.succeed(gateway)
+});
+const makeClientFromAi = (definition, ai) => {
+	const gateway = tryAiGatewaySync(definition.binding, "gateway", () => ai.gateway(definition.gatewayId));
+	const withGateway = (operation) => gateway.pipe(Effect.flatMap(operation));
+	return {
+		definition,
+		run: (data, options) => withGateway((raw) => makeClient(definition, raw).run(data, options)),
+		getUrl: (provider) => withGateway((raw) => makeClient(definition, raw).getUrl(provider)),
+		fetch: (options) => withGateway((raw) => makeClient(definition, raw).fetch(options)),
+		patchLog: (logId, data) => withGateway((raw) => makeClient(definition, raw).patchLog(logId, data)),
+		getLog: (logId) => withGateway((raw) => makeClient(definition, raw).getLog(logId)),
+		rawUnsafe: gateway
+	};
+};
+const makeHttpClient = (definition, request = fetch) => {
+	const binding = definition.binding ?? "AI_GATEWAY";
+	const clientDefinition = {
+		binding,
+		gatewayId: definition.gatewayId,
+		accountId: definition.accountId
+	};
+	const getUrl = (provider) => Effect.succeed(provider === void 0 ? gatewayUrl(definition) : providerUrl(gatewayUrl(definition), provider).href.replace(/\/$/, ""));
+	const extraHeaders = (options) => {
+		if (options?.extraHeaders === void 0 || Array.isArray(options.extraHeaders) || options.extraHeaders instanceof Headers) return options?.extraHeaders;
+		return Object.fromEntries(Object.entries(options.extraHeaders).map(([key, value]) => [key, String(value)]));
+	};
+	return {
+		definition: clientDefinition,
+		run: Effect.fn("AiGateway.run")((data, options) => tryAiGatewayPromise(binding, "run", (signal) => request(gatewayUrl(definition), {
+			method: "POST",
+			body: JSON.stringify(data),
+			headers: new Headers({
+				"content-type": "application/json",
+				...Object.fromEntries(new Headers(extraHeaders(options)).entries())
+			}),
+			signal: mergeAbortSignals(options?.signal, signal)
+		}))),
+		getUrl,
+		fetch: Effect.fn("AiGateway.fetch")((options) => getUrl(options.provider).pipe(Effect.flatMap((baseUrl) => tryAiGatewayPromise(binding, "fetch", (signal) => request(providerUrl(baseUrl, options.path).href, {
+			...options.init,
+			signal: mergeAbortSignals(options.init?.signal, signal)
+		}))))),
+		patchLog: Effect.fn("AiGateway.patchLog")((logId, data) => tryAiGatewayPromise(binding, "patchLog", async (signal) => {
+			const response = await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, {
+				method: "PATCH",
+				body: JSON.stringify(data),
+				headers: { "content-type": "application/json" },
+				signal
+			});
+			ensureSuccessfulResponse(response);
+			await decodeAiGatewayPatchLogResponse(await response.json());
+		})),
+		getLog: Effect.fn("AiGateway.getLog")((logId) => tryAiGatewayPromise(binding, "getLog", async (signal) => {
+			const response = await request(providerUrl(gatewayUrl(definition), `logs/${logId}`).href, { signal });
+			ensureSuccessfulResponse(response);
+			return (await decodeAiGatewayLogResponse(await response.json())).result;
+		})),
+		rawUnsafe: Effect.fail(aiGatewayError(binding, "rawUnsafe", /* @__PURE__ */ new TypeError("HTTP AI Gateway clients have no raw binding")))
+	};
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, isAiGatewayBinding, (ai) => makeClientFromAi(definition, ai), { expected: expectedAiGatewayBinding });
+const make = (id) => Tag()(id);
+const Tag = () => (id) => {
+	const tag = Context.Service()(id);
+	const makeLayer = (definition) => layer(tag, definition);
+	return Object.assign(tag, {
+		id,
+		layer: makeLayer
+	});
+};
+//#endregion
+export { AiGatewayOperationError, AiGateway_exports, Tag, isAiGatewayBinding, layer, make, makeClient, makeClientFromAi, makeHttpClient };

package/dist/AnalyticsEngine.d.mts

@@ -0,0 +1,170 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as S from "effect/Schema";
+import * as Layer$1 from "effect/Layer";
+import * as Config$1 from "effect/Config";
+import * as Option from "effect/Option";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+import { Redacted } from "effect";
+import { Headers, HttpClientResponse } from "effect/unstable/http";
+declare namespace AnalyticsEngine_d_exports {
+  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, 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: S.Struct<{
+  readonly name: S.String;
+  readonly type: S.String;
+}>;
+declare const queryRowSchema: S.$Record<S.String, S.Unknown>;
+declare const AnalyticsEngineFieldValueSchema: S.NullOr<S.Union<readonly [S.String, S.instanceOf<ArrayBuffer, unknown>]>>;
+declare const AnalyticsEngineDataPointSchema: S.Struct<{
+  readonly indexes: S.optional<S.$Array<S.NullOr<S.Union<readonly [S.String, S.instanceOf<ArrayBuffer, unknown>]>>>>;
+  readonly doubles: S.optional<S.$Array<S.Finite>>;
+  readonly blobs: S.optional<S.$Array<S.NullOr<S.Union<readonly [S.String, S.instanceOf<ArrayBuffer, unknown>]>>>>;
+}>;
+declare const AnalyticsEngineOperationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "AnalyticsEngineOperationError";
+} & Readonly<A>;
+declare class AnalyticsEngineOperationError extends AnalyticsEngineOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+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: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "AnalyticsEngineWriteValidationError";
+} & Readonly<A>;
+declare class AnalyticsEngineWriteValidationError extends AnalyticsEngineWriteValidationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly violations: ReadonlyArray<AnalyticsEngineWriteViolation>;
+  readonly cause?: unknown;
+}> {
+  get message(): string;
+}
+declare const AnalyticsEngineQueryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "AnalyticsEngineQueryError";
+} & Readonly<A>;
+declare class AnalyticsEngineQueryError extends AnalyticsEngineQueryError_base<{
+  readonly operation: string;
+  readonly accountId: string;
+  readonly message: string;
+  readonly status?: number;
+  readonly body?: string;
+  readonly cause?: unknown;
+}> {}
+interface AnalyticsEngineDefinition {
+  readonly binding: string;
+}
+type AnalyticsEngineBinding = CloudflareAnalyticsEngineDataset;
+type AnalyticsEngineDataPoint = CloudflareAnalyticsEngineDataPoint;
+type AnalyticsEngineFieldValue = ArrayBuffer | string | null;
+type AnalyticsEngineWriteError = AnalyticsEngineOperationError | AnalyticsEngineWriteValidationError;
+type AnalyticsEngineInvalidWritePolicy = "error" | "drop";
+type AnalyticsEngineQueryColumn = S.Schema.Type<typeof queryColumnSchema>;
+type AnalyticsEngineQueryRow = S.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;
+}
+type AnalyticsEngineWritePolicy = AnalyticsEngineWriteOptions;
+interface AnalyticsEngineQueryResult<Row = AnalyticsEngineQueryRow> {
+  readonly meta: ReadonlyArray<AnalyticsEngineQueryColumn>;
+  readonly data: ReadonlyArray<Row>;
+  readonly rows: number;
+}
+interface AnalyticsEngineQueryDefinition {
+  readonly accountId: string;
+  /** API token with Account Analytics Read permission. */
+  readonly apiToken: Redacted.Redacted<string>;
+  readonly apiBaseUrl?: string | URL;
+}
+interface AnalyticsEngineQueryOptions {
+  /** Additional request headers. Authorization is always derived from `apiToken`. */
+  readonly headers?: Headers.Input;
+}
+interface AnalyticsEngineClient {
+  readonly writeDataPoint: (dataPoint?: AnalyticsEngineDataPoint, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly writeDataPoints: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint>, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly rawUnsafe: Effect.Effect<AnalyticsEngineBinding>;
+  readonly definition: AnalyticsEngineDefinition;
+}
+interface AnalyticsEngineQueryClient {
+  readonly query: (sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<AnalyticsEngineQueryResult, AnalyticsEngineQueryError | S.SchemaError>;
+  readonly queryResult: <Row>(row: S.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<AnalyticsEngineQueryResult<Row>, AnalyticsEngineQueryError | S.SchemaError>;
+  readonly queryRows: <Row>(row: S.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<ReadonlyArray<Row>, AnalyticsEngineQueryError | S.SchemaError>;
+  readonly queryOne: <Row>(row: S.Codec<Row, unknown>, sql: string, options?: AnalyticsEngineQueryOptions) => Effect.Effect<Option.Option<Row>, AnalyticsEngineQueryError | S.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;
+interface AnalyticsEngineService<Id extends string> {
+  readonly [AnalyticsEngineServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+interface AnalyticsEngineQueryService<Id extends string> {
+  readonly [AnalyticsEngineQueryServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+  readonly write?: AnalyticsEngineWritePolicy;
+};
+type QueryConfigOptions = {
+  readonly accountId?: Config$1.Config<string>;
+  readonly apiToken?: Config$1.Config<Redacted.Redacted<string>>;
+  readonly apiBaseUrl?: Config$1.Config<string>;
+};
+interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self, Id, AnalyticsEngineClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer$1.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+interface QueryTagClass<Self, Id extends string> extends Context$1.ServiceClass<Self, Id, AnalyticsEngineQueryClient> {
+  readonly id: Id;
+  readonly layer: (definition: AnalyticsEngineQueryDefinition) => Layer$1.Layer<Self, never, HttpClient.HttpClient>;
+  readonly layerFetch: (definition: AnalyticsEngineQueryDefinition) => Layer$1.Layer<Self>;
+  readonly layerConfig: (config?: Config$1.Config<AnalyticsEngineQueryDefinition>) => Layer$1.Layer<Self, Config$1.ConfigError, HttpClient.HttpClient>;
+  readonly layerFetchConfig: (config?: Config$1.Config<AnalyticsEngineQueryDefinition>) => Layer$1.Layer<Self, Config$1.ConfigError>;
+}
+declare const makeQueryClient: (definition: AnalyticsEngineQueryDefinition) => Effect.Effect<AnalyticsEngineQueryClient, never, HttpClient.HttpClient>;
+declare const isAnalyticsEngineDataset: <Candidate>(value: Candidate) => value is Candidate & AnalyticsEngineBinding;
+declare const makeClient: (definition: AnalyticsEngineDefinition, defaults?: AnalyticsEngineWritePolicy) => (dataset: AnalyticsEngineBinding) => AnalyticsEngineClient;
+declare const queryConfig: (options?: QueryConfigOptions) => Config$1.Config<{
+  accountId: string;
+  apiToken: Redacted.Redacted<string>;
+  apiBaseUrl: string;
+}>;
+declare const queryLayer: <Self>(tag: Context$1.Service<Self, AnalyticsEngineQueryClient>, definition: AnalyticsEngineQueryDefinition) => Layer$1.Layer<Self, never, HttpClient.HttpClient>;
+declare const layerFetch: <Self>(tag: Context$1.Service<Self, AnalyticsEngineQueryClient>, definition: AnalyticsEngineQueryDefinition) => Layer$1.Layer<Self, never, never>;
+declare const queryLayerConfig: <Self>(tag: Context$1.Service<Self, AnalyticsEngineQueryClient>, config?: Config$1.Config<AnalyticsEngineQueryDefinition>) => Layer$1.Layer<Self, Config$1.ConfigError, HttpClient.HttpClient>;
+declare const layerFetchConfig: <Self>(tag: Context$1.Service<Self, AnalyticsEngineQueryClient>, config?: Config$1.Config<AnalyticsEngineQueryDefinition>) => Layer$1.Layer<Self, Config$1.ConfigError, never>;
+declare const layer: <Self>(tag: Context$1.Service<Self, AnalyticsEngineClient>, definition: LayerOptions) => Layer$1.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<AnalyticsEngineService<Id>, Id>;
+declare const makeQuery: <Id extends string>(id: Id) => QueryTagClass<AnalyticsEngineQueryService<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+declare const QueryTag: <Self>() => <Id extends string>(id: Id) => QueryTagClass<Self, Id>;
+//#endregion
+export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, AnalyticsEngine_d_exports, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };