effect-cf 0.40.0 → 0.40.1

package/dist/Email.mjs

@@ -0,0 +1,247 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer as layer$1 } from "./Binding.mjs";
+import { causeMessage, violationsMessage } from "./internal/ErrorMessage.mjs";
+import * as Context from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+//#region src/Email.ts
+var Email_exports = /* @__PURE__ */ __exportAll({
+	EmailOperationError: () => EmailOperationError,
+	EmailValidationError: () => EmailValidationError,
+	Tag: () => Tag,
+	emailErrorCodes: () => emailErrorCodes,
+	isEmailBinding: () => isEmailBinding,
+	layer: () => layer,
+	make: () => make,
+	makeClient: () => makeClient,
+	sendLimits: () => sendLimits,
+	validateMessage: () => validateMessage
+});
+const expectedSendEmailBinding = "Send Email binding with send()";
+const textEncoder = new TextEncoder();
+const sendLimits = {
+	maxRecipients: 50,
+	maxAttachments: 32,
+	maxMessageBytes: 5242880,
+	maxHeaderNameBytes: 100,
+	maxHeaderValueBytes: 2048,
+	maxHeadersBytes: 16384,
+	maxAllowlistHeaders: 20
+};
+/**
+* Error codes reported by Cloudflare Email Sending.
+*
+* Surfaced on {@link EmailOperationError} `code` on a best-effort basis: the
+* runtime attaches them as a non-standard `code` property on thrown errors,
+* which may be missing depending on the runtime or dev-time proxying
+* (miniflare remote bindings serialize errors and can strip it).
+*/
+const emailErrorCodes = [
+	"E_VALIDATION_ERROR",
+	"E_FIELD_MISSING",
+	"E_TOO_MANY_RECIPIENTS",
+	"E_TOO_MANY_ATTACHMENTS",
+	"E_SENDER_NOT_VERIFIED",
+	"E_RECIPIENT_NOT_ALLOWED",
+	"E_RECIPIENT_SUPPRESSED",
+	"E_SENDER_DOMAIN_NOT_AVAILABLE",
+	"E_CONTENT_TOO_LARGE",
+	"E_DELIVERY_FAILED",
+	"E_RATE_LIMIT_EXCEEDED",
+	"E_DAILY_LIMIT_EXCEEDED",
+	"E_INTERNAL_SERVER_ERROR",
+	"E_HEADER_NOT_ALLOWED",
+	"E_HEADER_USE_API_FIELD",
+	"E_HEADER_VALUE_INVALID",
+	"E_HEADER_VALUE_TOO_LONG",
+	"E_HEADER_NAME_INVALID",
+	"E_HEADERS_TOO_LARGE",
+	"E_HEADERS_TOO_MANY"
+];
+var EmailOperationError = class extends Data.TaggedError("EmailOperationError") {
+	get message() {
+		const code = this.code === void 0 ? "" : ` (${this.code})`;
+		return `Email ${this.operation} failed for binding "${this.binding}"${code}: ${causeMessage(this.cause)}`;
+	}
+};
+var EmailValidationError = class extends Data.TaggedError("EmailValidationError") {
+	get message() {
+		return `Email ${this.operation} for binding "${this.binding}" failed validation: ${violationsMessage(this.violations)}`;
+	}
+};
+/**
+* Best-effort extraction of the Cloudflare error `code` from a thrown error.
+* Returns `undefined` when the property is absent — e.g. when a dev-time
+* proxy such as a miniflare remote binding (`"remote": true`) serializes the
+* error and strips non-standard properties.
+*/
+const emailErrorCode = (cause) => {
+	if (!Predicate.isObject(cause)) return;
+	const code = Predicate.hasProperty(cause, "code") ? cause.code : void 0;
+	return Predicate.isString(code) ? code : void 0;
+};
+const emailError = (binding, operation, cause) => new EmailOperationError({
+	binding,
+	operation,
+	cause,
+	code: emailErrorCode(cause)
+});
+const emailValidationError = (binding, operation, violations) => new EmailValidationError({
+	binding,
+	operation,
+	violations
+});
+const tryEmailPromise = (binding, operation, evaluate) => Effect.tryPromise({
+	try: evaluate,
+	catch: (cause) => emailError(binding, operation, cause)
+});
+const byteLength = (value) => textEncoder.encode(value).byteLength;
+const limitViolation = (path, label, actual, limit) => ({
+	path,
+	message: `${label} exceeds Cloudflare Email Sending limit`,
+	actual,
+	limit
+});
+const addressList = (value) => {
+	if (value === void 0) return [];
+	return Array.isArray(value) ? value : [value];
+};
+const addressViolations = (path, value) => {
+	if (Predicate.isString(value)) return value.includes("@") ? [] : [{
+		path,
+		message: "Email address must contain an @ symbol"
+	}];
+	if (!Predicate.isObject(value)) return [{
+		path,
+		message: "Email address must be a string or { name, email } object"
+	}];
+	const email = Predicate.hasProperty(value, "email") ? value.email : void 0;
+	if (!Predicate.isString(email) || !email.includes("@")) return [{
+		path: `${path}.email`,
+		message: "Email address must contain an @ symbol"
+	}];
+	return [];
+};
+const recipientViolations = (field, value) => addressList(value).flatMap((address, index) => addressViolations(`${field}[${index}]`, address));
+const attachmentViolations = (attachments) => {
+	const violations = [];
+	if (attachments.length > sendLimits.maxAttachments) violations.push(limitViolation("attachments", "attachments", attachments.length, sendLimits.maxAttachments));
+	for (let index = 0; index < attachments.length; index++) {
+		const attachment = attachments[index];
+		const path = `attachments[${index}]`;
+		if (!Predicate.isObject(attachment)) {
+			violations.push({
+				path,
+				message: "Attachment must be an object"
+			});
+			continue;
+		}
+		if (!Predicate.isString(attachment.filename) || attachment.filename === "") violations.push({
+			path: `${path}.filename`,
+			message: "Attachment filename is required"
+		});
+		if (!Predicate.isString(attachment.type) || attachment.type === "") violations.push({
+			path: `${path}.type`,
+			message: "Attachment MIME type is required"
+		});
+		if (attachment.content === void 0 || attachment.content === null) violations.push({
+			path: `${path}.content`,
+			message: "Attachment content is required"
+		});
+		if (attachment.disposition === "inline" && !Predicate.isString(attachment.contentId)) violations.push({
+			path: `${path}.contentId`,
+			message: "Inline attachments require a contentId"
+		});
+	}
+	return violations;
+};
+const headerViolations = (headers) => {
+	const violations = [];
+	const entries = Object.entries(headers);
+	let totalBytes = 0;
+	let allowlistHeaders = 0;
+	for (const [name, value] of entries) {
+		const path = `headers["${name}"]`;
+		const nameBytes = byteLength(name);
+		if (nameBytes > sendLimits.maxHeaderNameBytes) violations.push(limitViolation(path, "header name bytes", nameBytes, sendLimits.maxHeaderNameBytes));
+		if (!Predicate.isString(value)) {
+			violations.push({
+				path,
+				message: "Header value must be a string"
+			});
+			continue;
+		}
+		const valueBytes = byteLength(value);
+		if (valueBytes > sendLimits.maxHeaderValueBytes) violations.push(limitViolation(path, "header value bytes", valueBytes, sendLimits.maxHeaderValueBytes));
+		totalBytes += nameBytes + valueBytes;
+		if (!name.toLowerCase().startsWith("x-")) allowlistHeaders += 1;
+	}
+	if (totalBytes > sendLimits.maxHeadersBytes) violations.push(limitViolation("headers", "header bytes", totalBytes, sendLimits.maxHeadersBytes));
+	if (allowlistHeaders > sendLimits.maxAllowlistHeaders) violations.push(limitViolation("headers", "allowlisted custom headers", allowlistHeaders, sendLimits.maxAllowlistHeaders));
+	return violations;
+};
+/**
+* Validates a structured message against documented Cloudflare Email Sending
+* limits and returns every violation found. Total message size is not checked
+* because the encoded MIME size is only known once Cloudflare composes it.
+*/
+const validateMessage = (message) => {
+	const violations = [];
+	const fields = message;
+	if (fields.from === void 0) violations.push({
+		path: "from",
+		message: "A from address is required"
+	});
+	else violations.push(...addressViolations("from", fields.from));
+	if (fields.replyTo !== void 0) violations.push(...addressViolations("replyTo", fields.replyTo));
+	if (!Predicate.isString(fields.subject) || fields.subject === "") violations.push({
+		path: "subject",
+		message: "A subject is required"
+	});
+	if (!Predicate.isString(fields.text) && !Predicate.isString(fields.html)) violations.push({
+		path: "$",
+		message: "A message requires either text or html content"
+	});
+	const recipients = addressList(fields.to).length + addressList(fields.cc).length + addressList(fields.bcc).length;
+	if (recipients === 0) violations.push({
+		path: "$",
+		message: "A message requires at least one to, cc, or bcc address"
+	});
+	if (recipients > sendLimits.maxRecipients) violations.push(limitViolation("$", "combined to, cc, and bcc addresses", recipients, sendLimits.maxRecipients));
+	violations.push(...recipientViolations("to", fields.to));
+	violations.push(...recipientViolations("cc", fields.cc));
+	violations.push(...recipientViolations("bcc", fields.bcc));
+	if (fields.attachments !== void 0) violations.push(...attachmentViolations(fields.attachments));
+	if (fields.headers !== void 0) violations.push(...headerViolations(fields.headers));
+	return violations;
+};
+const validateSendInput = (binding, operation, message) => {
+	const violations = validateMessage(message);
+	return violations.length > 0 ? Effect.fail(emailValidationError(binding, operation, violations)) : Effect.succeed(message);
+};
+const isEmailBinding = (value) => Predicate.hasProperty(value, "send") && Predicate.isFunction(value.send);
+const makeClient = (definition, options) => (email) => {
+	const runtime = email;
+	const validate = options?.validate ?? true;
+	return {
+		definition,
+		send: Effect.fn("Email.send")(function* (message) {
+			if (validate) yield* validateSendInput(definition.binding, "send", message);
+			return yield* tryEmailPromise(definition.binding, "send", () => runtime.send(message));
+		}),
+		rawUnsafe: Effect.succeed(email)
+	};
+};
+const layer = (tag, definition) => layer$1(tag, definition.binding, isEmailBinding, makeClient(definition, definition.send), { expected: expectedSendEmailBinding });
+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 { EmailOperationError, EmailValidationError, Email_exports, Tag, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };

package/dist/Environment.d.mts

@@ -0,0 +1,59 @@
+import * as Context$1 from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Config$1 from "effect/Config";
+import * as ConfigProvider from "effect/ConfigProvider";
+import { Layer } from "effect";
+declare namespace Environment_d_exports {
+  export { WorkerConfig, WorkerEnv, WorkerEnvironment };
+}
+type WorkerEnv = Cloudflare.Env;
+declare const WorkerEnvironment_base: Context$1.ServiceClass<WorkerEnvironment, "effect-cf/WorkerEnvironment", Cloudflare.Env>;
+/**
+ * Context service for reading worker bindings from the current `env` object.
+ */
+declare class WorkerEnvironment extends WorkerEnvironment_base {}
+type ScalarConfigValue = string | number | boolean;
+type ScalarConfigKey = Extract<{ readonly [Key in keyof Cloudflare.Env]-?: NonNullable<Cloudflare.Env[Key]> extends ScalarConfigValue ? Key : never; }[keyof Cloudflare.Env], string>;
+declare namespace WorkerConfig {
+  type Scalar = ScalarConfigValue;
+  type Key = ScalarConfigKey;
+  /** Read a scalar Cloudflare var or secret as a string. */
+  const string: <const Name extends Key>(name: Name) => Config$1.Config<string>;
+  /** Read a scalar Cloudflare secret as a redacted string. */
+  const redacted: <const Name extends Key>(name: Name) => Config$1.Config<import("effect/Redacted").Redacted<string>>;
+  /** Read a scalar Cloudflare var or secret as a number. */
+  const number: <const Name extends Key>(name: Name) => Config$1.Config<number>;
+  /** Read a scalar Cloudflare var or secret as an integer. */
+  const integer: <const Name extends Key>(name: Name) => Config$1.Config<number>;
+  /** Read a scalar Cloudflare var or secret as a boolean. */
+  const boolean: <const Name extends Key>(name: Name) => Config$1.Config<boolean>;
+  interface ProviderOptions {
+    /**
+     * Keep empty-string env values as explicit `""` config values.
+     *
+     * By default (absent or `false`), empty strings are treated as missing
+     * config, matching `ConfigProvider.fromEnvRecord`.
+     */
+    readonly preserveEmptyStrings?: boolean;
+  }
+  /**
+   * Build a `ConfigProvider` from a Cloudflare worker `env` object.
+   *
+   * Scalar vars and secrets use Effect's environment-record semantics;
+   * Cloudflare binding objects are ignored.
+   *
+   * Empty-string values are treated as missing config by default; pass
+   * `{ preserveEmptyStrings: true }` to keep them as explicit values.
+   */
+  const providerFromEnv: (env: WorkerEnv, options?: ProviderOptions) => ConfigProvider.ConfigProvider;
+  const providerWith: (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) => Effect.Effect<ConfigProvider.ConfigProvider, never, WorkerEnvironment>;
+  const provider: Effect.Effect<ConfigProvider.ConfigProvider, never, WorkerEnvironment>;
+  /**
+   * Replace the active Effect `ConfigProvider` with one backed by the current
+   * Cloudflare worker `env` object.
+   */
+  const providerLayer: Layer.Layer<never, never, WorkerEnvironment>;
+  const layerWith: (makeProvider: (env: WorkerEnv) => ConfigProvider.ConfigProvider) => Layer.Layer<never, never, WorkerEnvironment>;
+}
+//#endregion
+export { Environment_d_exports, WorkerConfig, WorkerEnv, WorkerEnvironment };

package/dist/{ErrorMessage-Byx2OgNd.mjs → Environment.mjs}

@@ -1,5 +1,9 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { Config, ConfigProvider, Context, Effect, Predicate } from "effect";
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import * as Config from "effect/Config";
+import * as ConfigProvider from "effect/ConfigProvider";
 //#region src/Environment.ts
 var Environment_exports = /* @__PURE__ */ __exportAll({
 	WorkerConfig: () => WorkerConfig,
@@ -27,19 +31,4 @@ let WorkerConfig;
 	_WorkerConfig.layerWith = (makeProvider) => ConfigProvider.layer(providerWith(makeProvider));
 })(WorkerConfig || (WorkerConfig = {}));
 //#endregion
-//#region src/internal/ErrorMessage.ts
-/**
-* Renders the most useful human-readable description of an unknown `cause`
-* for use in tagged error `message` getters.
-*/
-const causeMessage = (cause) => {
-	if (Predicate.hasProperty(cause, "message") && Predicate.isString(cause.message) && cause.message.length > 0) return cause.message;
-	try {
-		return String(cause);
-	} catch {
-		return "unknown cause";
-	}
-};
-const violationsMessage = (violations) => violations.map((violation) => `${violation.path}: ${violation.message}`).join("; ");
-//#endregion
-export { WorkerEnvironment as a, WorkerConfig as i, violationsMessage as n, Environment_exports as r, causeMessage as t };
+export { Environment_exports, WorkerConfig, WorkerEnvironment };

package/dist/{Hyperdrive-HrwFlZ6x.d.mts → Hyperdrive.d.mts}

@@ -1,5 +1,8 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
-import { Context, Effect, Layer } from "effect";
+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 { Layer } from "effect";
 declare namespace Hyperdrive_d_exports {
   export { HyperdriveClient, HyperdriveDefinition, HyperdriveService, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };
 }
@@ -20,14 +23,14 @@ interface HyperdriveService<Id extends string> {
 type LayerOptions = {
   readonly binding: string;
 };
-interface TagClass<Self, Id extends string> extends Context.ServiceClass<Self, Id, HyperdriveClient> {
+interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self, Id, HyperdriveClient> {
   readonly id: Id;
   readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 declare const isHyperdrive: <Candidate>(value: Candidate) => value is Candidate & Hyperdrive;
 declare const makeClient: (definition: HyperdriveDefinition) => (hyperdrive: Hyperdrive) => HyperdriveClient;
-declare const layer: <Self>(tag: Context.Service<Self, HyperdriveClient>, definition: HyperdriveDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const layer: <Self>(tag: Context$1.Service<Self, HyperdriveClient>, definition: HyperdriveDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make: <Id extends string>(id: Id) => TagClass<HyperdriveService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { LayerOptions as n, TagClass as r, Hyperdrive_d_exports as t };
+export { HyperdriveClient, HyperdriveDefinition, HyperdriveService, Hyperdrive_d_exports, LayerOptions, Tag, TagClass, isHyperdrive, layer, make, makeClient };

package/dist/Hyperdrive.mjs

@@ -0,0 +1,32 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
+import { layer as layer$1 } from "./Binding.mjs";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+//#region src/Hyperdrive.ts
+var Hyperdrive_exports = /* @__PURE__ */ __exportAll({
+	Tag: () => Tag,
+	isHyperdrive: () => isHyperdrive,
+	layer: () => layer,
+	make: () => make,
+	makeClient: () => makeClient
+});
+const expectedHyperdrive = "Hyperdrive binding with connectionString";
+const isHyperdrive = (value) => Predicate.hasProperty(value, "connectionString") && Predicate.isString(value.connectionString);
+const makeClient = (definition) => (hyperdrive) => ({
+	definition,
+	connectionString: hyperdrive.connectionString,
+	rawUnsafe: Effect.succeed(hyperdrive)
+});
+const layer = (tag, definition) => layer$1(tag, definition.binding, isHyperdrive, makeClient(definition), { expected: expectedHyperdrive });
+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 { Hyperdrive_exports, Tag, isHyperdrive, layer, make, makeClient };

package/dist/HyperdrivePg.d.mts

@@ -1,6 +1,7 @@
-import { c as WorkerEnvironment, r as BindingValidationError, t as BindingNotFoundError } from "./Binding-DKcLrQCM.mjs";
-import { n as LayerOptions, r as TagClass } from "./Hyperdrive-HrwFlZ6x.mjs";
-import { Layer } from "effect";
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import { LayerOptions, TagClass } from "./Hyperdrive.mjs";
+import * as Layer from "effect/Layer";
 import { PgClient } from "@effect/sql-pg";
 import { SqlClient, SqlError } from "effect/unstable/sql";
 //#region src/HyperdrivePg.d.ts

package/dist/HyperdrivePg.mjs

@@ -1,5 +1,7 @@
-import { Effect, Layer, Redacted } from "effect";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
 import { PgClient } from "@effect/sql-pg";
+import * as Redacted from "effect/Redacted";
 //#region src/HyperdrivePg.ts
 const layer = (tag, binding, options) => PgClient.layerFrom(Effect.flatMap(tag, (hyperdrive) => PgClient.makeClient({
 	...options,

package/dist/Images.d.mts

@@ -0,0 +1,191 @@
+import { WorkerEnvironment } from "./Environment.mjs";
+import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
+import * as Context$1 from "effect/Context";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { Layer } from "effect";
+declare namespace Images_d_exports {
+  export { DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions, ImageDirectUploadResult, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageSignedUrlOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResponseOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions, ProcessOptions, Step, Steps, Tag, TagClass, TextOptions, TypeId, draw, empty, isImagesBinding, layer, make, makeClient, transform };
+}
+declare const TypeId: "~effect-cf/Images/Steps";
+type TypeId = typeof TypeId;
+declare const ImagesOperationError_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: "ImagesOperationError";
+} & Readonly<A>;
+declare class ImagesOperationError extends ImagesOperationError_base<{
+  readonly binding: string;
+  readonly operation: string;
+  readonly cause: unknown;
+}> {
+  get message(): string;
+}
+interface ImagesDefinition {
+  readonly binding: string;
+}
+type ImageInfoResponse = CloudflareImageInfoResponse;
+type ImageTransform = CloudflareImageTransform;
+type ImageDrawOptions = CloudflareImageDrawOptions;
+type ImageInputOptions = CloudflareImageInputOptions;
+type ImageOutputOptions = CloudflareImageOutputOptions;
+type ImageTransformationOutputOptions = CloudflareImageTransformationOutputOptions;
+type ImageTransformationResponseOptions = CloudflareImageTransformationResponseOptions;
+type ImageTransformationResult = CloudflareImageTransformationResult;
+type ImageUploadOptions = CloudflareImageUploadOptions;
+type ImageUpdateOptions = CloudflareImageUpdateOptions;
+type ImageListOptions = CloudflareImageListOptions;
+type ImageList = CloudflareImageList;
+type ImageMetadata = CloudflareImageMetadata;
+type ImageSignedUrlOptions = CloudflareImageSignedUrlOptions;
+type ImageDirectUploadOptions = CloudflareImageDirectUploadOptions;
+type ImageDirectUploadResult = CloudflareImageDirectUploadResult;
+type TextOptions = CloudflareTextOptions;
+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;
+}>;
+declare const Step: {
+  readonly $is: <Tag extends "Draw" | "Transform">(tag: Tag) => (u: unknown) => u is Extract<{
+    readonly _tag: "Draw";
+    readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+    readonly options?: ImageDrawOptions;
+  }, {
+    readonly _tag: Tag;
+  }> | Extract<{
+    readonly _tag: "Transform";
+    readonly transform: ImageTransform;
+  }, {
+    readonly _tag: Tag;
+  }>;
+  readonly $match: {
+    <Cases extends { readonly [Tag in "Draw" | "Transform"]: (args: Extract<{
+      readonly _tag: "Draw";
+      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+      readonly options?: ImageDrawOptions;
+    } | {
+      readonly _tag: "Transform";
+      readonly transform: ImageTransform;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(cases: Cases): (value: {
+      readonly _tag: "Draw";
+      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+      readonly options?: ImageDrawOptions;
+    } | {
+      readonly _tag: "Transform";
+      readonly transform: ImageTransform;
+    }) => import("effect/Unify").Unify<ReturnType<Cases["Draw" | "Transform"]>>;
+    <Cases extends { readonly [Tag in "Draw" | "Transform"]: (args: Extract<{
+      readonly _tag: "Draw";
+      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+      readonly options?: ImageDrawOptions;
+    } | {
+      readonly _tag: "Transform";
+      readonly transform: ImageTransform;
+    }, {
+      readonly _tag: Tag;
+    }>) => any; }>(value: {
+      readonly _tag: "Draw";
+      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+      readonly options?: ImageDrawOptions;
+    } | {
+      readonly _tag: "Transform";
+      readonly transform: ImageTransform;
+    }, cases: Cases): import("effect/Unify").Unify<ReturnType<Cases["Draw" | "Transform"]>>;
+  };
+  readonly Draw: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Draw";
+    readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
+    readonly options?: ImageDrawOptions;
+  }, "_tag">;
+  readonly Transform: Data.TaggedEnum.ConstructorFrom<{
+    readonly _tag: "Transform";
+    readonly transform: ImageTransform;
+  }, "_tag">;
+};
+interface Steps {
+  readonly [TypeId]: typeof TypeId;
+  readonly steps: ReadonlyArray<Step>;
+}
+type ProcessOptions = {
+  readonly stream: ImageInputValue;
+  readonly inputOptions?: ImageInputOptions;
+  readonly outputOptions: ImageOutputOptions;
+} | {
+  readonly text: string;
+  readonly textOptions: TextOptions;
+  readonly outputOptions: ImageOutputOptions;
+};
+interface ImagesTransformationResultClient {
+  readonly raw: CloudflareImageTransformationResult;
+  readonly response: (options?: ImageTransformationResponseOptions) => 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 signedUrl: (options: ImageSignedUrlOptions) => Effect.Effect<string, 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 createDirectUpload: (options?: ImageDirectUploadOptions) => Effect.Effect<ImageDirectUploadResult, ImagesOperationError>;
+  readonly rawUnsafe: Effect.Effect<CloudflareHostedImagesBinding>;
+}
+interface ImagesRuntimeBinding {
+  readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Promise<ImageInfoResponse>;
+  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => CloudflareImageTransformer;
+  readonly text?: (content: string, options: TextOptions) => 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 text: (content: string, options: TextOptions) => Effect.Effect<CloudflareImageTransformer, ImagesOperationError>;
+  readonly process: (steps: Steps, options: ProcessOptions) => Effect.Effect<ImagesTransformationResultClient, ImagesOperationError>;
+  readonly hosted: Option.Option<HostedImagesClient>;
+  readonly rawUnsafe: Effect.Effect<ImagesRuntimeBinding>;
+  readonly definition: ImagesDefinition;
+}
+declare const ImagesServiceTypeId: unique symbol;
+interface ImagesService<Id extends string> {
+  readonly [ImagesServiceTypeId]: {
+    readonly id: Id;
+  };
+}
+type LayerOptions = {
+  readonly binding: string;
+};
+interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self, Id, ImagesClient> {
+  readonly id: Id;
+  readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+}
+declare const empty: Steps;
+declare const transform: {
+  (transform: ImageTransform): (steps: Steps) => Steps;
+  (steps: Steps, transform: ImageTransform): Steps;
+};
+declare const draw: {
+  (draw: DrawStepOptions): (steps: Steps) => Steps;
+  (steps: Steps, draw: DrawStepOptions): Steps;
+};
+declare const isImagesBinding: <Candidate>(value: Candidate) => value is Candidate & ImagesRuntimeBinding;
+declare const makeClient: (definition: ImagesDefinition) => (images: ImagesRuntimeBinding) => ImagesClient;
+declare const layer: <Self>(tag: Context$1.Service<Self, ImagesClient>, definition: ImagesDefinition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
+declare const make: <Id extends string>(id: Id) => TagClass<ImagesService<Id>, Id>;
+declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
+//#endregion
+export { DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions, ImageDirectUploadResult, ImageDrawOptions, ImageHandleClient, ImageInfoResponse, ImageInputOptions, ImageInputValue, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageSignedUrlOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResponseOptions, ImageTransformationResult, ImageUpdateOptions, ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, Images_d_exports, LayerOptions, ProcessOptions, Step, Steps, Tag, TagClass, TextOptions, TypeId, draw, empty, isImagesBinding, layer, make, makeClient, transform };