effect-cf 0.40.0 → 0.40.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # effect-cf
 
+## 0.40.2
+
+### Patch Changes
+
+- [#155](https://github.com/danieljvdm/effect-cf/pull/155) [`c23dd31`](https://github.com/danieljvdm/effect-cf/commit/c23dd319f7ea018f803de31095937c2ca69eb0ed) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Fix initialization failures when importing Queue or Workflow definitions from the published ES modules. Their factory exports remain the same functions regardless of module evaluation order.
+
+## 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

package/README.md

@@ -8,6 +8,8 @@ npm install effect-cf "effect@^4.0.0-rc.112"
 
 The repository tests against workerd `1.20260825.1` and `@cloudflare/workers-types@5.20260825.1`. Use `compatibility_date: "2026-08-25"` in Wrangler.
 
+See the [runtime performance guide](https://github.com/danieljvdm/effect-cf/blob/main/docs/runtime-performance.md) for measured alarm batching and telemetry configuration guidance.
+
 ## Worker
 
 ```ts

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 };