effect-cf 0.46.0 → 0.46.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # effect-cf
 
+## 0.46.1
+
+### Patch Changes
+
+- [#188](https://github.com/danieljvdm/effect-cf/pull/188) [`731938e`](https://github.com/danieljvdm/effect-cf/commit/731938ec635355c769f451b6153f8eb806ad98c1) Thanks [@limwa](https://github.com/limwa)! - Fix declaration portability by referencing consumer-provided Cloudflare Workers globals instead of importing `@cloudflare/workers-types`.
+
 ## 0.46.0
 
 ### Minor Changes

package/dist/AiGateway.d.mts

@@ -3,7 +3,6 @@ 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 { AiGateway } from "@cloudflare/workers-types";
 import { Layer } from "effect";
 declare namespace AiGateway_d_exports {
   export { AiGatewayBinding, AiGatewayClient, AiGatewayDefinition, AiGatewayFetchOptions, AiGatewayHeaders, AiGatewayLog, AiGatewayOperationError, AiGatewayPatchLog, AiGatewayProvider, AiGatewayRunOptions, AiGatewayService, AiGatewayUniversalRequest, BindingNotFoundError, BindingValidationError, LayerOptions, Tag, TagClass, isAiGatewayBinding, layer, make, makeClient, makeClientFromAi, makeHttpClient };
@@ -30,7 +29,7 @@ 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<AiGateway["run"]>[1];
+type AiGatewayRunOptions = Parameters<AiGatewayBinding["run"]>[1];
 type AiGatewayBindingCandidate = Parameters<typeof isWorkersAiBinding>[0];
 interface AiGatewayFetchOptions {
   readonly provider?: AiGatewayProvider;
@@ -64,15 +63,15 @@ interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self,
 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;
+  run: (data: AIGatewayUniversalRequest | readonly AIGatewayUniversalRequest[], options?: {
+    gateway?: UniversalGatewayOptions;
     extraHeaders?: object;
-    signal?: import("@cloudflare/workers-types").AbortSignal;
-  } | undefined) => Effect.Effect<import("@cloudflare/workers-types").Response, AiGatewayOperationError, never>;
+    signal?: AbortSignal;
+  } | undefined) => Effect.Effect<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>;
+  patchLog: (logId: string, data: globalThis.AiGatewayPatchLog) => Effect.Effect<void, AiGatewayOperationError, never>;
+  getLog: (logId: string) => Effect.Effect<globalThis.AiGatewayLog, AiGatewayOperationError, never>;
   rawUnsafe: Effect.Effect<AiGateway, never, never>;
 };
 declare const makeClientFromAi: (definition: AiGatewayDefinition, ai: WorkersAiBinding) => AiGatewayClient;

package/dist/AnalyticsEngine.d.mts

@@ -7,11 +7,10 @@ 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 { AnalyticsEngineDataPoint, AnalyticsEngineDataset } from "@cloudflare/workers-types";
 import { Redacted } from "effect";
 import { Headers, HttpClientResponse } from "effect/unstable/http";
 declare namespace AnalyticsEngine_d_exports {
-  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint$1 as AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, BindingNotFoundError, BindingValidationError, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
+  export { AnalyticsEngineBinding, AnalyticsEngineClient, AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, BindingNotFoundError, BindingValidationError, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
 }
 declare const writeLimits: {
   readonly maxBlobs: 20;
@@ -74,7 +73,7 @@ interface AnalyticsEngineDefinition {
   readonly binding: string;
 }
 type AnalyticsEngineBinding = AnalyticsEngineDataset;
-type AnalyticsEngineDataPoint$1 = AnalyticsEngineDataPoint;
+type AnalyticsEngineDataPoint = globalThis.AnalyticsEngineDataPoint;
 type AnalyticsEngineFieldValue = ArrayBuffer | string | null;
 type AnalyticsEngineWriteError = AnalyticsEngineOperationError | AnalyticsEngineWriteValidationError;
 type AnalyticsEngineInvalidWritePolicy = "error" | "drop";
@@ -104,8 +103,8 @@ interface AnalyticsEngineQueryOptions {
   readonly headers?: Headers.Input;
 }
 interface AnalyticsEngineClient {
-  readonly writeDataPoint: (dataPoint?: AnalyticsEngineDataPoint$1, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
-  readonly writeDataPoints: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint$1>, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  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;
 }
@@ -168,4 +167,4 @@ declare const makeQuery: <Id extends string>(id: Id) => QueryTagClass<AnalyticsE
 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$1 as AnalyticsEngineDataPoint, AnalyticsEngineDataPointSchema, AnalyticsEngineDefinition, AnalyticsEngineFieldValue, AnalyticsEngineFieldValueSchema, AnalyticsEngineInvalidWritePolicy, AnalyticsEngineOperationError, AnalyticsEngineQueryClient, AnalyticsEngineQueryColumn, AnalyticsEngineQueryDefinition, AnalyticsEngineQueryError, AnalyticsEngineQueryOptions, AnalyticsEngineQueryResult, AnalyticsEngineQueryRow, AnalyticsEngineQueryService, AnalyticsEngineService, AnalyticsEngineWriteError, AnalyticsEngineWriteOptions, AnalyticsEngineWritePolicy, AnalyticsEngineWriteValidationError, AnalyticsEngineWriteViolation, AnalyticsEngine_d_exports, type BindingNotFoundError, type BindingValidationError, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };
+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, type BindingNotFoundError, type BindingValidationError, LayerOptions, QueryConfigOptions, QueryTag, QueryTagClass, Tag, TagClass, isAnalyticsEngineDataset, layer, layerFetch, layerFetchConfig, make, makeClient, makeQuery, makeQueryClient, queryConfig, queryLayer, queryLayerConfig, writeLimits };

package/dist/Artifacts.d.mts

@@ -2,10 +2,9 @@ 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 { ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsErrorCode, ArtifactsRepoInfo, ArtifactsTokenInfo, ArtifactsTokenListResult } from "@cloudflare/workers-types";
 import { Layer } from "effect";
 declare namespace Artifacts_d_exports {
-  export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult$1 as ArtifactsCreateRepoResult, ArtifactsCreateTokenResult$1 as ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode$1 as ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo$1 as ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo$1 as ArtifactsTokenInfo, ArtifactsTokenListResult$1 as ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, BindingNotFoundError, BindingValidationError, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
+  export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, BindingNotFoundError, BindingValidationError, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
 }
 type ArtifactsOperation = "createClient" | "create" | "get" | "import" | "list" | "delete" | "createToken" | "listTokens" | "getToken" | "revokeToken" | "fork" | "info" | "log" | "readCommit" | "readTree" | "cli";
 declare const artifactsErrorCodes: readonly ["ALREADY_EXISTS", "NOT_FOUND", "IMPORT_IN_PROGRESS", "FORK_IN_PROGRESS", "INVALID_INPUT", "INVALID_REPO_NAME", "INVALID_TTL", "INVALID_URL", "REMOTE_AUTH_REQUIRED", "UPSTREAM_UNAVAILABLE", "MEMORY_LIMIT", "INTERNAL_ERROR"];
@@ -23,7 +22,7 @@ declare const artifactsErrorNumericCodes: {
   readonly MEMORY_LIMIT: 10402;
   readonly INTERNAL_ERROR: 10400;
 };
-type ArtifactsErrorCode$1 = ArtifactsErrorCode;
+type ArtifactsErrorCode = globalThis.ArtifactsErrorCode;
 declare const ArtifactsOperationError_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: "ArtifactsOperationError";
 } & Readonly<A>;
@@ -31,7 +30,7 @@ declare class ArtifactsOperationError extends ArtifactsOperationError_base<{
   readonly binding: string;
   readonly operation: ArtifactsOperation;
   readonly cause: unknown;
-  readonly code?: ArtifactsErrorCode$1 | (string & {});
+  readonly code?: ArtifactsErrorCode | (string & {});
   readonly numericCode?: number;
 }> {
   get message(): string;
@@ -46,9 +45,9 @@ type ArtifactsTokenScope = "read" | "write";
 /** Lifecycle state of a repository token. */
 type ArtifactsTokenState = "active" | "expired" | "revoked";
 type ArtifactsRepoStatus = "ready" | "importing" | "forking";
-type ArtifactsRepoInfo$1 = ArtifactsRepoInfo;
-type ArtifactsCreateRepoResult$1 = Readonly<ArtifactsCreateRepoResult>;
-interface ArtifactsRepoListEntry extends ArtifactsRepoInfo$1 {
+type ArtifactsRepoInfo = globalThis.ArtifactsRepoInfo;
+type ArtifactsCreateRepoResult = Readonly<globalThis.ArtifactsCreateRepoResult>;
+interface ArtifactsRepoListEntry extends ArtifactsRepoInfo {
   readonly status: ArtifactsRepoStatus;
 }
 interface ArtifactsRepoListResult {
@@ -57,11 +56,11 @@ interface ArtifactsRepoListResult {
   readonly cursor?: Cursor;
 }
 /** Result of creating a repository token. */
-type ArtifactsCreateTokenResult$1 = ArtifactsCreateTokenResult;
+type ArtifactsCreateTokenResult = globalThis.ArtifactsCreateTokenResult;
 /** Repository token metadata, excluding its plaintext secret. */
-type ArtifactsTokenInfo$1 = ArtifactsTokenInfo;
+type ArtifactsTokenInfo = globalThis.ArtifactsTokenInfo;
 /** Repository token list result. */
-type ArtifactsTokenListResult$1 = ArtifactsTokenListResult;
+type ArtifactsTokenListResult = globalThis.ArtifactsTokenListResult;
 /** Identity recorded for a Git commit author or committer. */
 interface ArtifactsCommitIdentity {
   readonly name: string;
@@ -126,7 +125,7 @@ interface ArtifactsLogOptions {
   readonly limit?: number;
   readonly offset?: number;
 }
-interface ArtifactsRepoBinding extends Partial<ArtifactsRepoInfo$1> {
+interface ArtifactsRepoBinding extends Partial<ArtifactsRepoInfo> {
   /**
    * Read repository metadata.
    *
@@ -134,49 +133,49 @@ interface ArtifactsRepoBinding extends Partial<ArtifactsRepoInfo$1> {
    * through this method. It is optional solely for compatibility with older
    * local handles that expose metadata as data properties.
    */
-  readonly info?: () => Promise<ArtifactsRepoInfo$1>;
+  readonly info?: () => Promise<ArtifactsRepoInfo>;
   /**
    * Create a Git token for the repository.
    *
    * Scope defaults to `"write"`. TTL is measured in seconds, defaults to
    * 86,400, and must be between 60 and 31,536,000.
    */
-  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Promise<ArtifactsCreateTokenResult$1>;
-  readonly listTokens: () => Promise<ArtifactsTokenListResult$1>;
+  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Promise<ArtifactsCreateTokenResult>;
+  readonly listTokens: () => Promise<ArtifactsTokenListResult>;
   readonly revokeToken: (tokenOrId: string) => Promise<boolean>;
-  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Promise<ArtifactsCreateRepoResult$1>;
+  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Promise<ArtifactsCreateRepoResult>;
   readonly log: (options?: ArtifactsLogOptions) => Promise<ArtifactsLogResult>;
   readonly readCommit: (hash: string) => Promise<ArtifactsCommit>;
   readonly readTree: (hash: string) => Promise<ArtifactsTree>;
 }
 interface ArtifactsBinding {
-  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Promise<ArtifactsCreateRepoResult$1>;
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Promise<ArtifactsCreateRepoResult>;
   readonly get: (name: RepoName) => Promise<ArtifactsRepoBinding>;
-  readonly import: (params: ArtifactsImportParams) => Promise<ArtifactsCreateRepoResult$1>;
+  readonly import: (params: ArtifactsImportParams) => Promise<ArtifactsCreateRepoResult>;
   readonly list: (options?: ArtifactsListOptions) => Promise<ArtifactsRepoListResult>;
   readonly delete: (name: RepoName) => Promise<boolean>;
 }
-interface ArtifactsRepoClient extends ArtifactsRepoInfo$1 {
-  readonly info: () => Effect.Effect<ArtifactsRepoInfo$1, ArtifactsOperationError>;
+interface ArtifactsRepoClient extends ArtifactsRepoInfo {
+  readonly info: () => Effect.Effect<ArtifactsRepoInfo, ArtifactsOperationError>;
   /**
    * Create a Git token for the repository.
    *
    * Scope defaults to `"write"`. TTL is measured in seconds, defaults to
    * 86,400, and must be between 60 and 31,536,000.
    */
-  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Effect.Effect<ArtifactsCreateTokenResult$1, ArtifactsOperationError>;
-  readonly listTokens: Effect.Effect<ArtifactsTokenListResult$1, ArtifactsOperationError>;
+  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Effect.Effect<ArtifactsCreateTokenResult, ArtifactsOperationError>;
+  readonly listTokens: Effect.Effect<ArtifactsTokenListResult, ArtifactsOperationError>;
   readonly revokeToken: (tokenOrId: string) => Effect.Effect<boolean, ArtifactsOperationError>;
-  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Effect.Effect<ArtifactsCreateRepoResult$1, ArtifactsOperationError>;
+  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
   readonly log: (options?: ArtifactsLogOptions) => Effect.Effect<ArtifactsLogResult, ArtifactsOperationError>;
   readonly readCommit: (hash: string) => Effect.Effect<ArtifactsCommit, ArtifactsOperationError>;
   readonly readTree: (hash: string) => Effect.Effect<ArtifactsTree, ArtifactsOperationError>;
   readonly raw: ArtifactsRepoBinding;
 }
 interface ArtifactsClient {
-  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Effect.Effect<ArtifactsCreateRepoResult$1, ArtifactsOperationError>;
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
   readonly get: (name: RepoName) => Effect.Effect<ArtifactsRepoClient, ArtifactsOperationError>;
-  readonly import: (params: ArtifactsImportParams) => Effect.Effect<ArtifactsCreateRepoResult$1, ArtifactsOperationError>;
+  readonly import: (params: ArtifactsImportParams) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
   readonly list: (options?: ArtifactsListOptions) => Effect.Effect<ArtifactsRepoListResult, ArtifactsOperationError>;
   readonly delete: (name: RepoName) => Effect.Effect<boolean, ArtifactsOperationError>;
   readonly rawUnsafe: Effect.Effect<ArtifactsBinding>;
@@ -202,4 +201,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, ArtifactsClient>, defin
 declare const make: <Id extends string>(id: Id) => TagClass<ArtifactsService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult$1 as ArtifactsCreateRepoResult, ArtifactsCreateTokenResult$1 as ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode$1 as ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo$1 as ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo$1 as ArtifactsTokenInfo, ArtifactsTokenListResult$1 as ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, Artifacts_d_exports, type BindingNotFoundError, type BindingValidationError, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };
+export { ArtifactsBinding, ArtifactsClient, ArtifactsCommit, ArtifactsCommitIdentity, ArtifactsCreateOptions, ArtifactsCreateRepoResult, ArtifactsCreateTokenResult, ArtifactsDefinition, ArtifactsErrorCode, ArtifactsForkOptions, ArtifactsImportParams, ArtifactsImportSource, ArtifactsImportTarget, ArtifactsImportTargetOptions, ArtifactsListOptions, ArtifactsLogOptions, ArtifactsLogResult, ArtifactsOperation, ArtifactsOperationError, ArtifactsRepoBinding, ArtifactsRepoClient, ArtifactsRepoInfo, ArtifactsRepoListEntry, ArtifactsRepoListResult, ArtifactsRepoStatus, ArtifactsService, ArtifactsTokenInfo, ArtifactsTokenListResult, ArtifactsTokenScope, ArtifactsTokenState, ArtifactsTree, Artifacts_d_exports, type BindingNotFoundError, type BindingValidationError, Cursor, LayerOptions, RepoName, Tag, TagClass, artifactsErrorCodes, artifactsErrorNumericCodes, isArtifactsBinding, isArtifactsRepoBinding, layer, make, makeClient };

package/dist/Cache.d.mts

@@ -2,12 +2,11 @@ import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
-import { Cache, CacheQueryOptions, CacheStorage, RequestInfo } from "@cloudflare/workers-types";
 declare namespace Cache_d_exports {
-  export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions$1 as CacheQueryOptions, CacheRequest, CacheStorage$1 as CacheStorage, CacheStorageClient, layer, layerFrom, makeCacheClient, makeClient };
+  export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, layer, layerFrom, makeCacheClient, makeClient };
 }
 type CacheRequest = RequestInfo | URL;
-type CacheQueryOptions$1 = CacheQueryOptions;
+type CacheQueryOptions = globalThis.CacheQueryOptions;
 type CacheOperation = "open" | "match" | "put" | "delete";
 declare const CacheOperationError_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: "CacheOperationError";
@@ -21,21 +20,21 @@ declare class CacheOperationError extends CacheOperationError_base<{
 }
 interface CacheClient {
   readonly name: string;
-  readonly match: (request: CacheRequest, options?: CacheQueryOptions$1) => Effect.Effect<Option.Option<Response>, CacheOperationError>;
+  readonly match: (request: CacheRequest, options?: CacheQueryOptions) => Effect.Effect<Option.Option<Response>, CacheOperationError>;
   readonly put: (request: CacheRequest, response: Response) => Effect.Effect<void, CacheOperationError>;
-  readonly delete: (request: CacheRequest, options?: CacheQueryOptions$1) => Effect.Effect<boolean, CacheOperationError>;
+  readonly delete: (request: CacheRequest, options?: CacheQueryOptions) => Effect.Effect<boolean, CacheOperationError>;
   readonly rawUnsafe: Effect.Effect<Cache>;
 }
 interface CacheStorageClient {
   readonly default: CacheClient;
   readonly open: (name: string) => Effect.Effect<CacheClient, CacheOperationError>;
-  readonly rawUnsafe: Effect.Effect<CacheStorage>;
+  readonly rawUnsafe: Effect.Effect<globalThis.CacheStorage>;
 }
-declare const CacheStorage_base: Context.ServiceClass<CacheStorage$1, "effect-cf/CacheStorage", CacheStorageClient>;
-declare class CacheStorage$1 extends CacheStorage_base {}
+declare const CacheStorage_base: Context.ServiceClass<CacheStorage, "effect-cf/CacheStorage", CacheStorageClient>;
+declare class CacheStorage extends CacheStorage_base {}
 declare const makeCacheClient: (cache: Cache, name?: string) => CacheClient;
-declare const makeClient: (storage: CacheStorage) => CacheStorageClient;
-declare const layerFrom: (storage: CacheStorage) => Layer.Layer<CacheStorage$1>;
-declare const layer: Layer.Layer<CacheStorage$1>;
+declare const makeClient: (storage: globalThis.CacheStorage) => CacheStorageClient;
+declare const layerFrom: (storage: globalThis.CacheStorage) => Layer.Layer<CacheStorage>;
+declare const layer: Layer.Layer<CacheStorage>;
 //#endregion
-export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions$1 as CacheQueryOptions, CacheRequest, CacheStorage$1 as CacheStorage, CacheStorageClient, Cache_d_exports, layer, layerFrom, makeCacheClient, makeClient };
+export { CacheClient, CacheOperation, CacheOperationError, CacheQueryOptions, CacheRequest, CacheStorage, CacheStorageClient, Cache_d_exports, layer, layerFrom, makeCacheClient, makeClient };

package/dist/Email.d.mts

@@ -2,10 +2,9 @@ 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 { EmailAddress, EmailAttachment, EmailSendResult, SendEmail } from "@cloudflare/workers-types";
 import { Layer } from "effect";
 declare namespace Email_d_exports {
-  export { BindingNotFoundError, BindingValidationError, EmailAddress$1 as EmailAddress, EmailAttachment$1 as EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult$1 as EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };
+  export { BindingNotFoundError, BindingValidationError, EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };
 }
 declare const sendLimits: {
   readonly maxRecipients: 50;
@@ -63,18 +62,18 @@ declare class EmailValidationError extends EmailValidationError_base<{
 interface EmailDefinition {
   readonly binding: string;
 }
-type EmailAddress$1 = EmailAddress;
-type EmailAttachment$1 = EmailAttachment;
+type EmailAddress = globalThis.EmailAddress;
+type EmailAttachment = globalThis.EmailAttachment;
+type EmailSendResult = globalThis.EmailSendResult;
 type EmailMessageBuilder = Parameters<SendEmail["send"]>[0];
-type EmailSendResult$1 = EmailSendResult;
 type EmailBinding = SendEmail;
-type EmailRecipients = string | EmailAddress$1 | ReadonlyArray<string | EmailAddress$1>;
+type EmailRecipients = string | EmailAddress | ReadonlyArray<string | EmailAddress>;
 type EmailSendError = EmailOperationError | EmailValidationError;
 interface EmailSendOptions {
   readonly validate?: boolean;
 }
 interface EmailClient {
-  readonly send: (message: EmailMessageBuilder) => Effect.Effect<EmailSendResult$1, EmailSendError>;
+  readonly send: (message: EmailMessageBuilder) => Effect.Effect<EmailSendResult, EmailSendError>;
   readonly rawUnsafe: Effect.Effect<EmailBinding>;
   readonly definition: EmailDefinition;
 }
@@ -104,4 +103,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, EmailClient>, definitio
 declare const make: <Id extends string>(id: Id) => TagClass<EmailService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { type BindingNotFoundError, type BindingValidationError, EmailAddress$1 as EmailAddress, EmailAttachment$1 as EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult$1 as EmailSendResult, EmailService, EmailValidationError, EmailViolation, Email_d_exports, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };
+export { type BindingNotFoundError, type BindingValidationError, EmailAddress, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, Email_d_exports, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };

package/dist/Images.d.mts

@@ -4,10 +4,9 @@ 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 { HostedImagesBinding, ImageDirectUploadOptions, ImageDirectUploadResult, ImageDrawOptions, ImageHandle, ImageInfoResponse, ImageInputOptions, ImageList, ImageListOptions, ImageMetadata, ImageOutputOptions, ImageSignedUrlOptions, ImageTransform, ImageTransformationOutputOptions, ImageTransformationResponseOptions, ImageTransformationResult, ImageTransformer, ImageUpdateOptions, ImageUploadOptions, Response, TextOptions } from "@cloudflare/workers-types";
 import { Layer } from "effect";
 declare namespace Images_d_exports {
-  export { BindingNotFoundError, BindingValidationError, DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions$1 as ImageDirectUploadOptions, ImageDirectUploadResult$1 as ImageDirectUploadResult, ImageDrawOptions$1 as ImageDrawOptions, ImageHandleClient, ImageInfoResponse$1 as ImageInfoResponse, ImageInputOptions$1 as ImageInputOptions, ImageInputValue, ImageList$1 as ImageList, ImageListOptions$1 as ImageListOptions, ImageMetadata$1 as ImageMetadata, ImageOutputOptions$1 as ImageOutputOptions, ImageSignedUrlOptions$1 as ImageSignedUrlOptions, ImageTransform$1 as ImageTransform, ImageTransformationOutputOptions$1 as ImageTransformationOutputOptions, ImageTransformationResponseOptions$1 as ImageTransformationResponseOptions, ImageTransformationResult$1 as ImageTransformationResult, ImageUpdateOptions$1 as ImageUpdateOptions, ImageUploadOptions$1 as ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, LayerOptions, ProcessOptions, Step, Steps, Tag, TagClass, TextOptions$1 as TextOptions, TypeId, draw, empty, isImagesBinding, layer, make, makeClient, transform };
+  export { BindingNotFoundError, BindingValidationError, 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;
@@ -24,32 +23,32 @@ declare class ImagesOperationError extends ImagesOperationError_base<{
 interface ImagesDefinition {
   readonly binding: string;
 }
-type ImageInfoResponse$1 = ImageInfoResponse;
-type ImageTransform$1 = ImageTransform;
-type ImageDrawOptions$1 = ImageDrawOptions;
-type ImageInputOptions$1 = ImageInputOptions;
-type ImageOutputOptions$1 = ImageOutputOptions;
-type ImageTransformationOutputOptions$1 = ImageTransformationOutputOptions;
-type ImageTransformationResponseOptions$1 = ImageTransformationResponseOptions;
-type ImageTransformationResult$1 = ImageTransformationResult;
-type ImageUploadOptions$1 = ImageUploadOptions;
-type ImageUpdateOptions$1 = ImageUpdateOptions;
-type ImageListOptions$1 = ImageListOptions;
-type ImageList$1 = ImageList;
-type ImageMetadata$1 = ImageMetadata;
-type ImageSignedUrlOptions$1 = ImageSignedUrlOptions;
-type ImageDirectUploadOptions$1 = ImageDirectUploadOptions;
-type ImageDirectUploadResult$1 = ImageDirectUploadResult;
-type TextOptions$1 = TextOptions;
+type ImageDirectUploadOptions = globalThis.ImageDirectUploadOptions;
+type ImageDirectUploadResult = globalThis.ImageDirectUploadResult;
+type ImageDrawOptions = globalThis.ImageDrawOptions;
+type ImageInfoResponse = globalThis.ImageInfoResponse;
+type ImageInputOptions = globalThis.ImageInputOptions;
+type ImageList = globalThis.ImageList;
+type ImageListOptions = globalThis.ImageListOptions;
+type ImageMetadata = globalThis.ImageMetadata;
+type ImageOutputOptions = globalThis.ImageOutputOptions;
+type ImageSignedUrlOptions = globalThis.ImageSignedUrlOptions;
+type ImageTransform = globalThis.ImageTransform;
+type ImageTransformationOutputOptions = globalThis.ImageTransformationOutputOptions;
+type ImageTransformationResponseOptions = globalThis.ImageTransformationResponseOptions;
+type ImageTransformationResult = globalThis.ImageTransformationResult;
+type ImageUpdateOptions = globalThis.ImageUpdateOptions;
+type ImageUploadOptions = globalThis.ImageUploadOptions;
+type TextOptions = globalThis.TextOptions;
 type ImageInputValue = ReadableStream<Uint8Array> | ArrayBuffer;
 type ImageUploadValue = ReadableStream<Uint8Array> | ArrayBuffer;
 interface DrawStepOptions {
   readonly image: ReadableStream<Uint8Array> | ImageTransformer;
-  readonly options?: ImageDrawOptions$1;
+  readonly options?: ImageDrawOptions;
 }
 type Step = Data.TaggedEnum<{
   readonly Transform: {
-    readonly transform: ImageTransform$1;
+    readonly transform: ImageTransform;
   };
   readonly Draw: DrawStepOptions;
 }>;
@@ -57,12 +56,12 @@ declare const Step: {
   readonly $is: <Tag extends "Draw" | "Transform">(tag: Tag) => (u: unknown) => u is Extract<{
     readonly _tag: "Draw";
     readonly image: ReadableStream<Uint8Array> | ImageTransformer;
-    readonly options?: ImageDrawOptions$1;
+    readonly options?: ImageDrawOptions;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
     readonly _tag: "Transform";
-    readonly transform: ImageTransform$1;
+    readonly transform: ImageTransform;
   }, {
     readonly _tag: Tag;
   }>;
@@ -70,46 +69,46 @@ declare const Step: {
     <Cases extends { readonly [Tag in "Draw" | "Transform"]: (args: Extract<{
       readonly _tag: "Draw";
       readonly image: ReadableStream<Uint8Array> | ImageTransformer;
-      readonly options?: ImageDrawOptions$1;
+      readonly options?: ImageDrawOptions;
     } | {
       readonly _tag: "Transform";
-      readonly transform: ImageTransform$1;
+      readonly transform: ImageTransform;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
       readonly _tag: "Draw";
       readonly image: ReadableStream<Uint8Array> | ImageTransformer;
-      readonly options?: ImageDrawOptions$1;
+      readonly options?: ImageDrawOptions;
     } | {
       readonly _tag: "Transform";
-      readonly transform: ImageTransform$1;
+      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> | ImageTransformer;
-      readonly options?: ImageDrawOptions$1;
+      readonly options?: ImageDrawOptions;
     } | {
       readonly _tag: "Transform";
-      readonly transform: ImageTransform$1;
+      readonly transform: ImageTransform;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
       readonly _tag: "Draw";
       readonly image: ReadableStream<Uint8Array> | ImageTransformer;
-      readonly options?: ImageDrawOptions$1;
+      readonly options?: ImageDrawOptions;
     } | {
       readonly _tag: "Transform";
-      readonly transform: ImageTransform$1;
+      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> | ImageTransformer;
-    readonly options?: ImageDrawOptions$1;
+    readonly options?: ImageDrawOptions;
   }, "_tag">;
   readonly Transform: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Transform";
-    readonly transform: ImageTransform$1;
+    readonly transform: ImageTransform;
   }, "_tag">;
 };
 interface Steps {
@@ -118,44 +117,44 @@ interface Steps {
 }
 type ProcessOptions = {
   readonly stream: ImageInputValue;
-  readonly inputOptions?: ImageInputOptions$1;
-  readonly outputOptions: ImageOutputOptions$1;
+  readonly inputOptions?: ImageInputOptions;
+  readonly outputOptions: ImageOutputOptions;
 } | {
   readonly text: string;
-  readonly textOptions: TextOptions$1;
-  readonly outputOptions: ImageOutputOptions$1;
+  readonly textOptions: TextOptions;
+  readonly outputOptions: ImageOutputOptions;
 };
 interface ImagesTransformationResultClient {
   readonly raw: ImageTransformationResult;
-  readonly response: (options?: ImageTransformationResponseOptions$1) => Effect.Effect<Response, ImagesOperationError>;
+  readonly response: (options?: ImageTransformationResponseOptions) => Effect.Effect<Response, ImagesOperationError>;
   readonly contentType: Effect.Effect<string, ImagesOperationError>;
-  readonly image: (options?: ImageTransformationOutputOptions$1) => Effect.Effect<ReadableStream<Uint8Array>, ImagesOperationError>;
+  readonly image: (options?: ImageTransformationOutputOptions) => Effect.Effect<ReadableStream<Uint8Array>, ImagesOperationError>;
 }
 interface ImageHandleClient {
   readonly raw: ImageHandle;
-  readonly details: Effect.Effect<Option.Option<ImageMetadata$1>, ImagesOperationError>;
+  readonly details: Effect.Effect<Option.Option<ImageMetadata>, ImagesOperationError>;
   readonly bytes: Effect.Effect<Option.Option<ReadableStream<Uint8Array>>, ImagesOperationError>;
-  readonly signedUrl: (options: ImageSignedUrlOptions$1) => Effect.Effect<string, ImagesOperationError>;
-  readonly update: (options: ImageUpdateOptions$1) => Effect.Effect<ImageMetadata$1, 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$1) => Effect.Effect<ImageMetadata$1, ImagesOperationError>;
-  readonly list: (options?: ImageListOptions$1) => Effect.Effect<ImageList$1, ImagesOperationError>;
-  readonly createDirectUpload: (options?: ImageDirectUploadOptions$1) => Effect.Effect<ImageDirectUploadResult$1, ImagesOperationError>;
+  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<HostedImagesBinding>;
 }
 interface ImagesRuntimeBinding {
-  readonly info: (image: ImageInputValue, options?: ImageInputOptions$1) => Promise<ImageInfoResponse$1>;
-  readonly input: (image: ImageInputValue, options?: ImageInputOptions$1) => ImageTransformer;
-  readonly text?: (content: string, options: TextOptions$1) => ImageTransformer;
+  readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Promise<ImageInfoResponse>;
+  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => ImageTransformer;
+  readonly text?: (content: string, options: TextOptions) => ImageTransformer;
   readonly hosted?: HostedImagesBinding;
 }
 interface ImagesClient {
-  readonly info: (image: ImageInputValue, options?: ImageInputOptions$1) => Effect.Effect<ImageInfoResponse$1, ImagesOperationError>;
-  readonly input: (image: ImageInputValue, options?: ImageInputOptions$1) => Effect.Effect<ImageTransformer, ImagesOperationError>;
-  readonly text: (content: string, options: TextOptions$1) => Effect.Effect<ImageTransformer, ImagesOperationError>;
+  readonly info: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<ImageInfoResponse, ImagesOperationError>;
+  readonly input: (image: ImageInputValue, options?: ImageInputOptions) => Effect.Effect<ImageTransformer, ImagesOperationError>;
+  readonly text: (content: string, options: TextOptions) => Effect.Effect<ImageTransformer, ImagesOperationError>;
   readonly process: (steps: Steps, options: ProcessOptions) => Effect.Effect<ImagesTransformationResultClient, ImagesOperationError>;
   readonly hosted: Option.Option<HostedImagesClient>;
   readonly rawUnsafe: Effect.Effect<ImagesRuntimeBinding>;
@@ -176,8 +175,8 @@ interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self,
 }
 declare const empty: Steps;
 declare const transform: {
-  (transform: ImageTransform$1): (steps: Steps) => Steps;
-  (steps: Steps, transform: ImageTransform$1): Steps;
+  (transform: ImageTransform): (steps: Steps) => Steps;
+  (steps: Steps, transform: ImageTransform): Steps;
 };
 declare const draw: {
   (draw: DrawStepOptions): (steps: Steps) => Steps;
@@ -189,4 +188,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, ImagesClient>, definiti
 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 { type BindingNotFoundError, type BindingValidationError, DrawStepOptions, HostedImagesClient, ImageDirectUploadOptions$1 as ImageDirectUploadOptions, ImageDirectUploadResult$1 as ImageDirectUploadResult, ImageDrawOptions$1 as ImageDrawOptions, ImageHandleClient, ImageInfoResponse$1 as ImageInfoResponse, ImageInputOptions$1 as ImageInputOptions, ImageInputValue, ImageList$1 as ImageList, ImageListOptions$1 as ImageListOptions, ImageMetadata$1 as ImageMetadata, ImageOutputOptions$1 as ImageOutputOptions, ImageSignedUrlOptions$1 as ImageSignedUrlOptions, ImageTransform$1 as ImageTransform, ImageTransformationOutputOptions$1 as ImageTransformationOutputOptions, ImageTransformationResponseOptions$1 as ImageTransformationResponseOptions, ImageTransformationResult$1 as ImageTransformationResult, ImageUpdateOptions$1 as ImageUpdateOptions, ImageUploadOptions$1 as ImageUploadOptions, ImageUploadValue, ImagesClient, ImagesDefinition, ImagesOperationError, ImagesRuntimeBinding, ImagesService, ImagesTransformationResultClient, Images_d_exports, LayerOptions, ProcessOptions, Step, Steps, Tag, TagClass, TextOptions$1 as TextOptions, TypeId, draw, empty, isImagesBinding, layer, make, makeClient, transform };
+export { type BindingNotFoundError, type BindingValidationError, 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 };

package/dist/Kv.d.mts

@@ -4,7 +4,6 @@ import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import * as Option from "effect/Option";
-import { KVNamespaceListOptions, KVNamespacePutOptions } from "@cloudflare/workers-types";
 import { Layer } from "effect";
 declare namespace Kv_d_exports {
   export { BindingNotFoundError, BindingValidationError, Definition, KvClient, KvDefinition, KvListKey, KvListOptions, KvListResult, KvOperation, KvOperationError, KvPutOptions, KvWithMetadata, LayerOptions, Tag, TagClass, isKvNamespace, layer, makeClient };

package/dist/QueueBinding.d.mts

@@ -4,17 +4,16 @@ import { ServiceFreeSchema } from "./RpcDefinition.mjs";
 import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import * as Predicate from "effect/Predicate";
-import { MessageSendRequest, Queue, QueueMetrics, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse } from "@cloudflare/workers-types";
 import { Context } from "effect";
 declare namespace QueueBinding_d_exports {
-  export { MessageSendRequest$1 as MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics$1 as QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions$1 as QueueSendBatchOptions, QueueSendBatchResponse$1 as QueueSendBatchResponse, QueueSendOptions$1 as QueueSendOptions, QueueSendResponse$1 as QueueSendResponse, isQueue, layer, makeClient };
+  export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer, makeClient };
 }
-type QueueSendOptions$1 = QueueSendOptions;
-type QueueSendResponse$1 = QueueSendResponse;
-type QueueSendBatchOptions$1 = QueueSendBatchOptions;
-type QueueSendBatchResponse$1 = QueueSendBatchResponse;
-type QueueMetrics$1 = QueueMetrics;
-type MessageSendRequest$1<Body> = MessageSendRequest<Body>;
+type MessageSendRequest<Body> = globalThis.MessageSendRequest<Body>;
+type QueueMetrics = globalThis.QueueMetrics;
+type QueueSendBatchOptions = globalThis.QueueSendBatchOptions;
+type QueueSendBatchResponse = globalThis.QueueSendBatchResponse;
+type QueueSendOptions = globalThis.QueueSendOptions;
+type QueueSendResponse = globalThis.QueueSendResponse;
 type QueueProducer<Body> = Pick<Queue<Body>, "send"> & Partial<Pick<Queue<Body>, "sendBatch" | "metrics">>;
 type QueueCandidate = Parameters<typeof Predicate.isUnknown>[0];
 interface QueueBindingDefinition<Message extends ServiceFreeSchema> {
@@ -22,9 +21,9 @@ interface QueueBindingDefinition<Message extends ServiceFreeSchema> {
   readonly message: Message;
 }
 interface QueueBindingClient<Message extends ServiceFreeSchema> {
-  readonly send: (message: S.Schema.Type<Message>, options?: QueueSendOptions$1) => Effect.Effect<void, QueueOperationError | S.SchemaError>;
-  readonly sendBatch: (messages: Iterable<MessageSendRequest$1<S.Schema.Type<Message>>>, options?: QueueSendBatchOptions$1) => Effect.Effect<void, QueueOperationError | S.SchemaError>;
-  readonly metrics: () => Effect.Effect<QueueMetrics$1, QueueOperationError>;
+  readonly send: (message: S.Schema.Type<Message>, options?: QueueSendOptions) => Effect.Effect<void, QueueOperationError | S.SchemaError>;
+  readonly sendBatch: (messages: Iterable<MessageSendRequest<S.Schema.Type<Message>>>, options?: QueueSendBatchOptions) => Effect.Effect<void, QueueOperationError | S.SchemaError>;
+  readonly metrics: () => Effect.Effect<QueueMetrics, QueueOperationError>;
   readonly rawUnsafe: Effect.Effect<QueueProducer<S.Codec.Encoded<Message>>>;
 }
 declare const QueueOperationError_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 & {
@@ -40,4 +39,4 @@ declare const isQueue: <Body>(value: QueueCandidate) => value is QueueProducer<B
 declare const makeClient: <Message extends ServiceFreeSchema>(definition: QueueBindingDefinition<Message>) => ((queue: QueueProducer<S.Codec.Encoded<Message>>) => QueueBindingClient<Message>);
 declare const layer: <Self, Message extends ServiceFreeSchema>(tag: Context.Service<Self, QueueBindingClient<Message>>, definition: QueueBindingDefinition<Message>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 //#endregion
-export { MessageSendRequest$1 as MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueBinding_d_exports, QueueMetrics$1 as QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions$1 as QueueSendBatchOptions, QueueSendBatchResponse$1 as QueueSendBatchResponse, QueueSendOptions$1 as QueueSendOptions, QueueSendResponse$1 as QueueSendResponse, isQueue, layer, makeClient };
+export { MessageSendRequest, QueueBindingClient, QueueBindingDefinition, QueueBinding_d_exports, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer, makeClient };