effect-cf 0.44.0 → 0.45.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # effect-cf
 
+## 0.45.0
+
+### Minor Changes
+
+- [#183](https://github.com/danieljvdm/effect-cf/pull/183) [`138d799`](https://github.com/danieljvdm/effect-cf/commit/138d799b15cac583a3cefce85bb7c4f56b442857) Thanks [@limwa](https://github.com/limwa)! - Preserve Cloudflare type imports in generated declarations and expose `MessageSendRequest` through `Queue` and `QueueDefinition` so consumers can emit portable declarations for inferred `sendBatch` values.
+
+## 0.44.1
+
+### Patch Changes
+
+- [#180](https://github.com/danieljvdm/effect-cf/pull/180) [`c94adc5`](https://github.com/danieljvdm/effect-cf/commit/c94adc506142d5d30095e9a05d449fe407c568b3) Thanks [@danieljvdm](https://github.com/danieljvdm)! - Keep Durable Object native callbacks on microtask scheduling through completion so restoring the caller context cannot leave an input gate waiting on a blocked timer.
+
 ## 0.44.0
 
 ### Minor Changes

package/dist/AiGateway.d.mts

@@ -3,6 +3,7 @@ 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 };
@@ -22,14 +23,14 @@ interface AiGatewayDefinition {
   readonly gatewayId: string;
   readonly accountId?: string;
 }
-type AiGatewayBinding = CloudflareAiGateway;
+type AiGatewayBinding = AiGateway;
 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 AiGatewayRunOptions = Parameters<AiGateway["run"]>[1];
 type AiGatewayBindingCandidate = Parameters<typeof isWorkersAiBinding>[0];
 interface AiGatewayFetchOptions {
   readonly provider?: AiGatewayProvider;
@@ -72,7 +73,7 @@ declare const makeClient: (definition: AiGatewayDefinition, gateway: AiGatewayBi
   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>;
+  rawUnsafe: Effect.Effect<AiGateway, never, never>;
 };
 declare const makeClientFromAi: (definition: AiGatewayDefinition, ai: WorkersAiBinding) => AiGatewayClient;
 declare const makeHttpClient: (definition: Omit<AiGatewayDefinition, "binding"> & {

package/dist/AnalyticsEngine.d.mts

@@ -7,10 +7,11 @@ 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, 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$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 };
 }
 declare const writeLimits: {
   readonly maxBlobs: 20;
@@ -72,8 +73,8 @@ declare class AnalyticsEngineQueryError extends AnalyticsEngineQueryError_base<{
 interface AnalyticsEngineDefinition {
   readonly binding: string;
 }
-type AnalyticsEngineBinding = CloudflareAnalyticsEngineDataset;
-type AnalyticsEngineDataPoint = CloudflareAnalyticsEngineDataPoint;
+type AnalyticsEngineBinding = AnalyticsEngineDataset;
+type AnalyticsEngineDataPoint$1 = AnalyticsEngineDataPoint;
 type AnalyticsEngineFieldValue = ArrayBuffer | string | null;
 type AnalyticsEngineWriteError = AnalyticsEngineOperationError | AnalyticsEngineWriteValidationError;
 type AnalyticsEngineInvalidWritePolicy = "error" | "drop";
@@ -103,8 +104,8 @@ interface AnalyticsEngineQueryOptions {
   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 writeDataPoint: (dataPoint?: AnalyticsEngineDataPoint$1, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
+  readonly writeDataPoints: (dataPoints: ReadonlyArray<AnalyticsEngineDataPoint$1>, options?: AnalyticsEngineWriteOptions) => Effect.Effect<void, AnalyticsEngineWriteError>;
   readonly rawUnsafe: Effect.Effect<AnalyticsEngineBinding>;
   readonly definition: AnalyticsEngineDefinition;
 }
@@ -167,4 +168,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, 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$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 };

package/dist/Artifacts.d.mts

@@ -2,9 +2,10 @@ 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, 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 };
+  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 };
 }
 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"];
@@ -22,7 +23,7 @@ declare const artifactsErrorNumericCodes: {
   readonly MEMORY_LIMIT: 10402;
   readonly INTERNAL_ERROR: 10400;
 };
-type ArtifactsErrorCode = CloudflareArtifactsErrorCode;
+type ArtifactsErrorCode$1 = 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>;
@@ -30,7 +31,7 @@ declare class ArtifactsOperationError extends ArtifactsOperationError_base<{
   readonly binding: string;
   readonly operation: ArtifactsOperation;
   readonly cause: unknown;
-  readonly code?: ArtifactsErrorCode | (string & {});
+  readonly code?: ArtifactsErrorCode$1 | (string & {});
   readonly numericCode?: number;
 }> {
   get message(): string;
@@ -45,9 +46,9 @@ type ArtifactsTokenScope = "read" | "write";
 /** Lifecycle state of a repository token. */
 type ArtifactsTokenState = "active" | "expired" | "revoked";
 type ArtifactsRepoStatus = "ready" | "importing" | "forking";
-type ArtifactsRepoInfo = CloudflareArtifactsRepoInfo;
-type ArtifactsCreateRepoResult = Readonly<CloudflareArtifactsCreateRepoResult>;
-interface ArtifactsRepoListEntry extends ArtifactsRepoInfo {
+type ArtifactsRepoInfo$1 = ArtifactsRepoInfo;
+type ArtifactsCreateRepoResult$1 = Readonly<ArtifactsCreateRepoResult>;
+interface ArtifactsRepoListEntry extends ArtifactsRepoInfo$1 {
   readonly status: ArtifactsRepoStatus;
 }
 interface ArtifactsRepoListResult {
@@ -56,11 +57,11 @@ interface ArtifactsRepoListResult {
   readonly cursor?: Cursor;
 }
 /** Result of creating a repository token. */
-type ArtifactsCreateTokenResult = CloudflareArtifactsCreateTokenResult;
+type ArtifactsCreateTokenResult$1 = ArtifactsCreateTokenResult;
 /** Repository token metadata, excluding its plaintext secret. */
-type ArtifactsTokenInfo = CloudflareArtifactsTokenInfo;
+type ArtifactsTokenInfo$1 = ArtifactsTokenInfo;
 /** Repository token list result. */
-type ArtifactsTokenListResult = CloudflareArtifactsTokenListResult;
+type ArtifactsTokenListResult$1 = ArtifactsTokenListResult;
 /** Identity recorded for a Git commit author or committer. */
 interface ArtifactsCommitIdentity {
   readonly name: string;
@@ -125,7 +126,7 @@ interface ArtifactsLogOptions {
   readonly limit?: number;
   readonly offset?: number;
 }
-interface ArtifactsRepoBinding extends Partial<ArtifactsRepoInfo> {
+interface ArtifactsRepoBinding extends Partial<ArtifactsRepoInfo$1> {
   /**
    * Read repository metadata.
    *
@@ -133,49 +134,49 @@ interface ArtifactsRepoBinding extends Partial<ArtifactsRepoInfo> {
    * through this method. It is optional solely for compatibility with older
    * local handles that expose metadata as data properties.
    */
-  readonly info?: () => Promise<ArtifactsRepoInfo>;
+  readonly info?: () => Promise<ArtifactsRepoInfo$1>;
   /**
    * 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>;
-  readonly listTokens: () => Promise<ArtifactsTokenListResult>;
+  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Promise<ArtifactsCreateTokenResult$1>;
+  readonly listTokens: () => Promise<ArtifactsTokenListResult$1>;
   readonly revokeToken: (tokenOrId: string) => Promise<boolean>;
-  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Promise<ArtifactsCreateRepoResult>;
+  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Promise<ArtifactsCreateRepoResult$1>;
   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>;
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Promise<ArtifactsCreateRepoResult$1>;
   readonly get: (name: RepoName) => Promise<ArtifactsRepoBinding>;
-  readonly import: (params: ArtifactsImportParams) => Promise<ArtifactsCreateRepoResult>;
+  readonly import: (params: ArtifactsImportParams) => Promise<ArtifactsCreateRepoResult$1>;
   readonly list: (options?: ArtifactsListOptions) => Promise<ArtifactsRepoListResult>;
   readonly delete: (name: RepoName) => Promise<boolean>;
 }
-interface ArtifactsRepoClient extends ArtifactsRepoInfo {
-  readonly info: () => Effect.Effect<ArtifactsRepoInfo, ArtifactsOperationError>;
+interface ArtifactsRepoClient extends ArtifactsRepoInfo$1 {
+  readonly info: () => Effect.Effect<ArtifactsRepoInfo$1, 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, ArtifactsOperationError>;
-  readonly listTokens: Effect.Effect<ArtifactsTokenListResult, ArtifactsOperationError>;
+  readonly createToken: (scope?: ArtifactsTokenScope, ttl?: number) => Effect.Effect<ArtifactsCreateTokenResult$1, ArtifactsOperationError>;
+  readonly listTokens: Effect.Effect<ArtifactsTokenListResult$1, ArtifactsOperationError>;
   readonly revokeToken: (tokenOrId: string) => Effect.Effect<boolean, ArtifactsOperationError>;
-  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly fork: (name: RepoName, options?: ArtifactsForkOptions) => Effect.Effect<ArtifactsCreateRepoResult$1, 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, ArtifactsOperationError>;
+  readonly create: (name: RepoName, options?: ArtifactsCreateOptions) => Effect.Effect<ArtifactsCreateRepoResult$1, ArtifactsOperationError>;
   readonly get: (name: RepoName) => Effect.Effect<ArtifactsRepoClient, ArtifactsOperationError>;
-  readonly import: (params: ArtifactsImportParams) => Effect.Effect<ArtifactsCreateRepoResult, ArtifactsOperationError>;
+  readonly import: (params: ArtifactsImportParams) => Effect.Effect<ArtifactsCreateRepoResult$1, ArtifactsOperationError>;
   readonly list: (options?: ArtifactsListOptions) => Effect.Effect<ArtifactsRepoListResult, ArtifactsOperationError>;
   readonly delete: (name: RepoName) => Effect.Effect<boolean, ArtifactsOperationError>;
   readonly rawUnsafe: Effect.Effect<ArtifactsBinding>;
@@ -201,4 +202,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, 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 };
+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 };

package/dist/Cache.d.mts

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

package/dist/Email.d.mts

@@ -2,9 +2,10 @@ 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, EmailAttachment, EmailBinding, EmailClient, EmailDefinition, EmailErrorCode, EmailMessageBuilder, EmailOperationError, EmailRecipients, EmailSendError, EmailSendOptions, EmailSendResult, EmailService, EmailValidationError, EmailViolation, LayerOptions, Tag, TagClass, emailErrorCodes, isEmailBinding, layer, make, makeClient, sendLimits, validateMessage };
+  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 };
 }
 declare const sendLimits: {
   readonly maxRecipients: 50;
@@ -62,18 +63,18 @@ declare class EmailValidationError extends EmailValidationError_base<{
 interface EmailDefinition {
   readonly binding: string;
 }
-type EmailAddress = CloudflareEmailAddress;
-type EmailAttachment = CloudflareEmailAttachment;
-type EmailMessageBuilder = Parameters<CloudflareSendEmail["send"]>[0];
-type EmailSendResult = CloudflareEmailSendResult;
-type EmailBinding = CloudflareSendEmail;
-type EmailRecipients = string | EmailAddress | ReadonlyArray<string | EmailAddress>;
+type EmailAddress$1 = EmailAddress;
+type EmailAttachment$1 = EmailAttachment;
+type EmailMessageBuilder = Parameters<SendEmail["send"]>[0];
+type EmailSendResult$1 = EmailSendResult;
+type EmailBinding = SendEmail;
+type EmailRecipients = string | EmailAddress$1 | ReadonlyArray<string | EmailAddress$1>;
 type EmailSendError = EmailOperationError | EmailValidationError;
 interface EmailSendOptions {
   readonly validate?: boolean;
 }
 interface EmailClient {
-  readonly send: (message: EmailMessageBuilder) => Effect.Effect<EmailSendResult, EmailSendError>;
+  readonly send: (message: EmailMessageBuilder) => Effect.Effect<EmailSendResult$1, EmailSendError>;
   readonly rawUnsafe: Effect.Effect<EmailBinding>;
   readonly definition: EmailDefinition;
 }
@@ -103,4 +104,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, 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 };
+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 };

package/dist/Images.d.mts

@@ -4,9 +4,10 @@ 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, 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 };
+  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 };
 }
 declare const TypeId: "~effect-cf/Images/Steps";
 type TypeId = typeof TypeId;
@@ -23,92 +24,92 @@ declare class ImagesOperationError extends ImagesOperationError_base<{
 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 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 ImageInputValue = ReadableStream<Uint8Array> | ArrayBuffer;
 type ImageUploadValue = ReadableStream<Uint8Array> | ArrayBuffer;
 interface DrawStepOptions {
-  readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
-  readonly options?: ImageDrawOptions;
+  readonly image: ReadableStream<Uint8Array> | ImageTransformer;
+  readonly options?: ImageDrawOptions$1;
 }
 type Step = Data.TaggedEnum<{
   readonly Transform: {
-    readonly transform: ImageTransform;
+    readonly transform: ImageTransform$1;
   };
   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 image: ReadableStream<Uint8Array> | ImageTransformer;
+    readonly options?: ImageDrawOptions$1;
   }, {
     readonly _tag: Tag;
   }> | Extract<{
     readonly _tag: "Transform";
-    readonly transform: ImageTransform;
+    readonly transform: ImageTransform$1;
   }, {
     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 image: ReadableStream<Uint8Array> | ImageTransformer;
+      readonly options?: ImageDrawOptions$1;
     } | {
       readonly _tag: "Transform";
-      readonly transform: ImageTransform;
+      readonly transform: ImageTransform$1;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(cases: Cases): (value: {
       readonly _tag: "Draw";
-      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
-      readonly options?: ImageDrawOptions;
+      readonly image: ReadableStream<Uint8Array> | ImageTransformer;
+      readonly options?: ImageDrawOptions$1;
     } | {
       readonly _tag: "Transform";
-      readonly transform: ImageTransform;
+      readonly transform: ImageTransform$1;
     }) => 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 image: ReadableStream<Uint8Array> | ImageTransformer;
+      readonly options?: ImageDrawOptions$1;
     } | {
       readonly _tag: "Transform";
-      readonly transform: ImageTransform;
+      readonly transform: ImageTransform$1;
     }, {
       readonly _tag: Tag;
     }>) => any; }>(value: {
       readonly _tag: "Draw";
-      readonly image: ReadableStream<Uint8Array> | CloudflareImageTransformer;
-      readonly options?: ImageDrawOptions;
+      readonly image: ReadableStream<Uint8Array> | ImageTransformer;
+      readonly options?: ImageDrawOptions$1;
     } | {
       readonly _tag: "Transform";
-      readonly transform: ImageTransform;
+      readonly transform: ImageTransform$1;
     }, 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;
+    readonly image: ReadableStream<Uint8Array> | ImageTransformer;
+    readonly options?: ImageDrawOptions$1;
   }, "_tag">;
   readonly Transform: Data.TaggedEnum.ConstructorFrom<{
     readonly _tag: "Transform";
-    readonly transform: ImageTransform;
+    readonly transform: ImageTransform$1;
   }, "_tag">;
 };
 interface Steps {
@@ -117,44 +118,44 @@ interface Steps {
 }
 type ProcessOptions = {
   readonly stream: ImageInputValue;
-  readonly inputOptions?: ImageInputOptions;
-  readonly outputOptions: ImageOutputOptions;
+  readonly inputOptions?: ImageInputOptions$1;
+  readonly outputOptions: ImageOutputOptions$1;
 } | {
   readonly text: string;
-  readonly textOptions: TextOptions;
-  readonly outputOptions: ImageOutputOptions;
+  readonly textOptions: TextOptions$1;
+  readonly outputOptions: ImageOutputOptions$1;
 };
 interface ImagesTransformationResultClient {
-  readonly raw: CloudflareImageTransformationResult;
-  readonly response: (options?: ImageTransformationResponseOptions) => Effect.Effect<CloudflareResponse, ImagesOperationError>;
+  readonly raw: ImageTransformationResult;
+  readonly response: (options?: ImageTransformationResponseOptions$1) => Effect.Effect<Response, ImagesOperationError>;
   readonly contentType: Effect.Effect<string, ImagesOperationError>;
-  readonly image: (options?: ImageTransformationOutputOptions) => Effect.Effect<ReadableStream<Uint8Array>, ImagesOperationError>;
+  readonly image: (options?: ImageTransformationOutputOptions$1) => Effect.Effect<ReadableStream<Uint8Array>, ImagesOperationError>;
 }
 interface ImageHandleClient {
-  readonly raw: CloudflareImageHandle;
-  readonly details: Effect.Effect<Option.Option<ImageMetadata>, ImagesOperationError>;
+  readonly raw: ImageHandle;
+  readonly details: Effect.Effect<Option.Option<ImageMetadata$1>, 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 signedUrl: (options: ImageSignedUrlOptions$1) => Effect.Effect<string, ImagesOperationError>;
+  readonly update: (options: ImageUpdateOptions$1) => Effect.Effect<ImageMetadata$1, 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>;
+  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 rawUnsafe: Effect.Effect<HostedImagesBinding>;
 }
 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;
+  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 hosted?: HostedImagesBinding;
 }
 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 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 process: (steps: Steps, options: ProcessOptions) => Effect.Effect<ImagesTransformationResultClient, ImagesOperationError>;
   readonly hosted: Option.Option<HostedImagesClient>;
   readonly rawUnsafe: Effect.Effect<ImagesRuntimeBinding>;
@@ -175,8 +176,8 @@ interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self,
 }
 declare const empty: Steps;
 declare const transform: {
-  (transform: ImageTransform): (steps: Steps) => Steps;
-  (steps: Steps, transform: ImageTransform): Steps;
+  (transform: ImageTransform$1): (steps: Steps) => Steps;
+  (steps: Steps, transform: ImageTransform$1): Steps;
 };
 declare const draw: {
   (draw: DrawStepOptions): (steps: Steps) => Steps;
@@ -188,4 +189,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, 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 };
+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 };

package/dist/Kv.d.mts

@@ -4,6 +4,7 @@ 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 };
@@ -19,8 +20,8 @@ declare class KvOperationError extends KvOperationError_base<{
 }> {
   get message(): string;
 }
-type KvPutOptions = CloudflareKVNamespacePutOptions;
-type KvListOptions<Metadata = unknown> = CloudflareKVNamespaceListOptions & {
+type KvPutOptions = KVNamespacePutOptions;
+type KvListOptions<Metadata = unknown> = KVNamespaceListOptions & {
   readonly metadataSchema?: S.Codec<Metadata, unknown>;
 };
 interface KvWithMetadata<Value, Metadata> {

package/dist/Queue.d.mts

@@ -1,12 +1,12 @@
 import { WorkerEnvironment } from "./Environment.mjs";
 import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
-import { QueueOperationError, QueueProducer } from "./QueueBinding.mjs";
+import { MessageSendRequest, QueueOperationError, QueueProducer } from "./QueueBinding.mjs";
 import { Definition as Definition$1, Handler as Handler$1, LayerOptions as LayerOptions$1, Options as Options$1, Tag, TagClass, implement } from "./QueueDefinition.mjs";
 import { ExecutionContext, WorkerContext } from "./Worker.mjs";
 import * as Effect from "effect/Effect";
 import { Scope } from "effect";
 declare namespace Queue_d_exports {
-  export { BindingNotFoundError, BindingValidationError, Definition, Handler, LayerOptions, Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOperationError, QueueOptions, QueueProducer, Tag, TagClass, decodeBatch, fromMessage, fromMessageBatch, implement };
+  export { BindingNotFoundError, BindingValidationError, Definition, Handler, LayerOptions, MessageSendRequest, Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, QueueOperationError, QueueOptions, QueueProducer, Tag, TagClass, decodeBatch, fromMessage, fromMessageBatch, implement };
 }
 interface QueueMessage<Body> {
   readonly raw: globalThis.Message<unknown>;
@@ -62,4 +62,4 @@ type LayerOptions = LayerOptions$1;
 type Handler<ROut, Self extends Definition$1.Any> = Handler$1<ROut, Self>;
 type Options<ROut, Self extends Definition$1.Any> = Options$1<ROut, Self>;
 //#endregion
-export { type BindingNotFoundError, type BindingValidationError, Definition, Handler, LayerOptions, Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, type QueueOperationError, QueueOptions, type QueueProducer, Queue_d_exports, Tag, type TagClass, decodeBatch, fromMessage, fromMessageBatch, implement };
+export { type BindingNotFoundError, type BindingValidationError, Definition, Handler, LayerOptions, type MessageSendRequest, Options, QueueBatch, QueueHandler, QueueMessage, QueueMessageDecodeError, type QueueOperationError, QueueOptions, type QueueProducer, Queue_d_exports, Tag, type TagClass, decodeBatch, fromMessage, fromMessageBatch, implement };

package/dist/QueueBinding.d.mts

@@ -4,26 +4,27 @@ 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, QueueBindingClient, QueueBindingDefinition, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer, makeClient };
+  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 };
 }
-type QueueSendOptions = CloudflareQueueSendOptions;
-type QueueSendResponse = CloudflareQueueSendResponse;
-type QueueSendBatchOptions = CloudflareQueueSendBatchOptions;
-type QueueSendBatchResponse = CloudflareQueueSendBatchResponse;
-type QueueMetrics = CloudflareQueueMetrics;
-type MessageSendRequest<Body> = CloudflareMessageSendRequest<Body>;
-type QueueProducer<Body> = Pick<CloudflareQueue<Body>, "send"> & Partial<Pick<CloudflareQueue<Body>, "sendBatch" | "metrics">>;
+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 QueueProducer<Body> = Pick<Queue<Body>, "send"> & Partial<Pick<Queue<Body>, "sendBatch" | "metrics">>;
 type QueueCandidate = Parameters<typeof Predicate.isUnknown>[0];
 interface QueueBindingDefinition<Message extends ServiceFreeSchema> {
   readonly binding: string;
   readonly message: Message;
 }
 interface QueueBindingClient<Message extends ServiceFreeSchema> {
-  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 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 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 & {
@@ -39,4 +40,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, QueueBindingClient, QueueBindingDefinition, QueueBinding_d_exports, QueueMetrics, QueueOperationError, QueueProducer, QueueSendBatchOptions, QueueSendBatchResponse, QueueSendOptions, QueueSendResponse, isQueue, layer, makeClient };
+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 };

package/dist/QueueDefinition.d.mts

@@ -9,7 +9,7 @@ import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import { Layer, Scope } from "effect";
 declare namespace QueueDefinition_d_exports {
-  export { BindingNotFoundError, BindingValidationError, Definition, Handler, LayerOptions, Options, Queue, QueueOperationError, QueueProducer, Tag, TagClass, implement, make };
+  export { BindingNotFoundError, BindingValidationError, Definition, Handler, LayerOptions, MessageSendRequest, Options, Queue, QueueOperationError, QueueProducer, Tag, TagClass, implement, make };
 }
 interface Definition<Id extends string = string, Message extends ServiceFreeSchema = ServiceFreeSchema> {
   readonly id: Id;
@@ -45,4 +45,4 @@ declare const Tag: <Self>() => <Id extends string, Message extends ServiceFreeSc
 declare const Queue: typeof Tag;
 declare const implement: <ROut, const Self extends Definition.Any>(_definition: Self, handler: Handler<ROut, Self>) => Handler<ROut, Self>;
 //#endregion
-export { type BindingNotFoundError, type BindingValidationError, Definition, Handler, LayerOptions, Options, Queue, QueueDefinition_d_exports, type QueueOperationError, type QueueProducer, Tag, TagClass, implement, make };
+export { type BindingNotFoundError, type BindingValidationError, Definition, Handler, LayerOptions, type MessageSendRequest, Options, Queue, QueueDefinition_d_exports, type QueueOperationError, type QueueProducer, Tag, TagClass, implement, make };

package/dist/R2.d.mts

@@ -4,9 +4,10 @@ import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Schema$1 from "effect/Schema";
 import * as Option from "effect/Option";
+import { R2Bucket, R2Conditional, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUpload, R2Object, R2ObjectBody, R2Objects, R2PutOptions, R2UploadPartOptions, R2UploadedPart } from "@cloudflare/workers-types";
 import { Layer } from "effect";
 declare namespace R2_d_exports {
-  export { BindingNotFoundError, BindingValidationError, LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2Operation, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, Tag, TagClass, isR2Bucket, layer, make, makeClient };
+  export { BindingNotFoundError, BindingValidationError, LayerOptions, R2Client, R2Definition, R2GetOptions$1 as R2GetOptions, R2ListOptions$1 as R2ListOptions, R2MultipartOptions$1 as R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2Operation, R2OperationError, R2PutOptions$1 as R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions$1 as R2UploadPartOptions, R2UploadPartValue, Tag, TagClass, isR2Bucket, layer, make, makeClient };
 }
 type R2Operation = "head" | "get" | "put" | "delete" | "list" | "createMultipartUpload" | "resumeMultipartUpload" | "uploadPart" | "abortMultipartUpload" | "completeMultipartUpload" | "arrayBuffer" | "bytes" | "text" | "json" | "blob";
 declare const R2OperationError_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 & {
@@ -22,15 +23,15 @@ declare class R2OperationError extends R2OperationError_base<{
 interface R2Definition {
   readonly binding: string;
 }
-type R2GetOptions = CloudflareR2GetOptions;
-type R2PutOptions = CloudflareR2PutOptions;
-type R2ListOptions = CloudflareR2ListOptions;
-type R2MultipartOptions = CloudflareR2MultipartOptions;
-type R2UploadPartOptions = CloudflareR2UploadPartOptions;
+type R2GetOptions$1 = R2GetOptions;
+type R2PutOptions$1 = R2PutOptions;
+type R2ListOptions$1 = R2ListOptions;
+type R2MultipartOptions$1 = R2MultipartOptions;
+type R2UploadPartOptions$1 = R2UploadPartOptions;
 type R2PutValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | null | Blob;
 type R2UploadPartValue = ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob;
-interface R2ObjectBodyClient extends Omit<CloudflareR2ObjectBody, "arrayBuffer" | "blob" | "bytes" | "json" | "text"> {
-  readonly raw: CloudflareR2ObjectBody;
+interface R2ObjectBodyClient extends Omit<R2ObjectBody, "arrayBuffer" | "blob" | "bytes" | "json" | "text"> {
+  readonly raw: R2ObjectBody;
   readonly arrayBuffer: Effect.Effect<ArrayBuffer, R2OperationError>;
   readonly bytes: Effect.Effect<Uint8Array, R2OperationError>;
   readonly text: Effect.Effect<string, R2OperationError>;
@@ -38,32 +39,32 @@ interface R2ObjectBodyClient extends Omit<CloudflareR2ObjectBody, "arrayBuffer"
   readonly blob: Effect.Effect<Blob, R2OperationError>;
 }
 interface R2MultipartUploadClient {
-  readonly raw: CloudflareR2MultipartUpload;
+  readonly raw: R2MultipartUpload;
   readonly key: string;
   readonly uploadId: string;
-  readonly uploadPart: (partNumber: number, value: R2UploadPartValue, options?: R2UploadPartOptions) => Effect.Effect<CloudflareR2UploadedPart, R2OperationError>;
+  readonly uploadPart: (partNumber: number, value: R2UploadPartValue, options?: R2UploadPartOptions$1) => Effect.Effect<R2UploadedPart, R2OperationError>;
   readonly abort: Effect.Effect<void, R2OperationError>;
-  readonly complete: (uploadedParts: ReadonlyArray<CloudflareR2UploadedPart>) => Effect.Effect<CloudflareR2Object, R2OperationError>;
+  readonly complete: (uploadedParts: ReadonlyArray<R2UploadedPart>) => Effect.Effect<R2Object, R2OperationError>;
 }
 interface R2Client {
-  readonly head: (key: string) => Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
+  readonly head: (key: string) => Effect.Effect<Option.Option<R2Object>, R2OperationError>;
   readonly get: {
-    (key: string, options: R2GetOptions & {
-      readonly onlyIf: CloudflareR2Conditional | Headers;
-    }): Effect.Effect<Option.Option<R2ObjectBodyClient | CloudflareR2Object>, R2OperationError>;
-    (key: string, options?: R2GetOptions): Effect.Effect<Option.Option<R2ObjectBodyClient>, R2OperationError>;
+    (key: string, options: R2GetOptions$1 & {
+      readonly onlyIf: R2Conditional | Headers;
+    }): Effect.Effect<Option.Option<R2ObjectBodyClient | R2Object>, R2OperationError>;
+    (key: string, options?: R2GetOptions$1): Effect.Effect<Option.Option<R2ObjectBodyClient>, R2OperationError>;
   };
   readonly put: {
-    (key: string, value: R2PutValue, options: R2PutOptions & {
-      readonly onlyIf: CloudflareR2Conditional | Headers;
-    }): Effect.Effect<Option.Option<CloudflareR2Object>, R2OperationError>;
-    (key: string, value: R2PutValue, options?: R2PutOptions): Effect.Effect<CloudflareR2Object, R2OperationError>;
+    (key: string, value: R2PutValue, options: R2PutOptions$1 & {
+      readonly onlyIf: R2Conditional | Headers;
+    }): Effect.Effect<Option.Option<R2Object>, R2OperationError>;
+    (key: string, value: R2PutValue, options?: R2PutOptions$1): Effect.Effect<R2Object, R2OperationError>;
   };
-  readonly createMultipartUpload: (key: string, options?: R2MultipartOptions) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
+  readonly createMultipartUpload: (key: string, options?: R2MultipartOptions$1) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
   readonly resumeMultipartUpload: (key: string, uploadId: string) => Effect.Effect<R2MultipartUploadClient, R2OperationError>;
   readonly delete: (keys: string | ReadonlyArray<string>) => Effect.Effect<void, R2OperationError>;
-  readonly list: (options?: R2ListOptions) => Effect.Effect<CloudflareR2Objects, R2OperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareR2Bucket>;
+  readonly list: (options?: R2ListOptions$1) => Effect.Effect<R2Objects, R2OperationError>;
+  readonly rawUnsafe: Effect.Effect<R2Bucket>;
   readonly definition: R2Definition;
 }
 declare const R2ServiceTypeId: unique symbol;
@@ -80,10 +81,10 @@ interface TagClass<Self, Id extends string> extends Context$1.ServiceClass<Self,
   readonly layer: (options: LayerOptions) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 }
 type R2BindingValue = Schema$1.Schema.Type<typeof Schema$1.Unknown>;
-declare const isR2Bucket: (value: R2BindingValue) => value is CloudflareR2Bucket;
-declare const makeClient: (definition: R2Definition) => ((bucket: CloudflareR2Bucket) => R2Client);
+declare const isR2Bucket: (value: R2BindingValue) => value is R2Bucket;
+declare const makeClient: (definition: R2Definition) => ((bucket: R2Bucket) => R2Client);
 declare const layer: <Self>(tag: Context$1.Service<Self, R2Client>, definition: R2Definition) => Layer.Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 declare const make: <Id extends string>(id: Id) => TagClass<R2Service<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { type BindingNotFoundError, type BindingValidationError, LayerOptions, R2Client, R2Definition, R2GetOptions, R2ListOptions, R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2Operation, R2OperationError, R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions, R2UploadPartValue, R2_d_exports, Tag, TagClass, isR2Bucket, layer, make, makeClient };
+export { type BindingNotFoundError, type BindingValidationError, LayerOptions, R2Client, R2Definition, R2GetOptions$1 as R2GetOptions, R2ListOptions$1 as R2ListOptions, R2MultipartOptions$1 as R2MultipartOptions, R2MultipartUploadClient, R2ObjectBodyClient, R2Operation, R2OperationError, R2PutOptions$1 as R2PutOptions, R2PutValue, R2Service, R2UploadPartOptions$1 as R2UploadPartOptions, R2UploadPartValue, R2_d_exports, Tag, TagClass, isR2Bucket, layer, make, makeClient };

package/dist/Vectorize.d.mts

@@ -3,9 +3,10 @@ import { BindingNotFoundError, BindingValidationError } from "./Binding.mjs";
 import * as Context$1 from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Schema$1 from "effect/Schema";
+import { Vectorize, VectorizeAsyncMutation, VectorizeIndex, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeQueryOptions, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, VectorizeVectorMutation } from "@cloudflare/workers-types";
 import { Layer } from "effect";
 declare namespace Vectorize_d_exports {
-  export { BindingNotFoundError, BindingValidationError, LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, isVectorizeBinding, layer, make, makeClient };
+  export { BindingNotFoundError, BindingValidationError, LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails$1 as VectorizeIndexDetails, VectorizeIndexInfo$1 as VectorizeIndexInfo, VectorizeMatch$1 as VectorizeMatch, VectorizeMatches$1 as VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions$1 as VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector$1 as VectorizeVector, VectorizeVectorMetadata$1 as VectorizeVectorMetadata, VectorizeVectorMetadataFilter$1 as VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue$1 as VectorizeVectorMetadataValue, isVectorizeBinding, layer, make, makeClient };
 }
 type VectorizeOperation = "describe" | "query" | "queryById" | "insert" | "upsert" | "deleteByIds" | "getByIds";
 declare const VectorizeOperationError_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 & {
@@ -21,27 +22,27 @@ declare class VectorizeOperationError extends VectorizeOperationError_base<{
 interface VectorizeDefinition {
   readonly binding: string;
 }
-type VectorizeBinding = CloudflareVectorize | CloudflareVectorizeIndex;
-type VectorizeVector = CloudflareVectorizeVector;
-type VectorizeVectorMetadata = CloudflareVectorizeVectorMetadata;
-type VectorizeVectorMetadataValue = CloudflareVectorizeVectorMetadataValue;
-type VectorizeVectorMetadataFilter = CloudflareVectorizeVectorMetadataFilter;
-type VectorizeQueryOptions = CloudflareVectorizeQueryOptions;
-type VectorizeMatches = CloudflareVectorizeMatches;
-type VectorizeMatch = CloudflareVectorizeMatch;
-type VectorizeIndexInfo = CloudflareVectorizeIndexInfo;
-type VectorizeIndexDetails = CloudflareVectorizeIndexDetails;
-type VectorizeMutation = CloudflareVectorizeAsyncMutation | CloudflareVectorizeVectorMutation;
+type VectorizeBinding = Vectorize | VectorizeIndex;
+type VectorizeVector$1 = VectorizeVector;
+type VectorizeVectorMetadata$1 = VectorizeVectorMetadata;
+type VectorizeVectorMetadataValue$1 = VectorizeVectorMetadataValue;
+type VectorizeVectorMetadataFilter$1 = VectorizeVectorMetadataFilter;
+type VectorizeQueryOptions$1 = VectorizeQueryOptions;
+type VectorizeMatches$1 = VectorizeMatches;
+type VectorizeMatch$1 = VectorizeMatch;
+type VectorizeIndexInfo$1 = VectorizeIndexInfo;
+type VectorizeIndexDetails$1 = VectorizeIndexDetails;
+type VectorizeMutation = VectorizeAsyncMutation | VectorizeVectorMutation;
 type VectorizeValues = Float32Array | Float64Array | ReadonlyArray<number>;
 interface VectorizeClient {
-  readonly describe: Effect.Effect<VectorizeIndexInfo | VectorizeIndexDetails, VectorizeOperationError>;
-  readonly query: (vector: VectorizeValues, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
-  readonly queryById: (vectorId: string, options?: VectorizeQueryOptions) => Effect.Effect<VectorizeMatches, VectorizeOperationError>;
-  readonly insert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
-  readonly upsert: (vectors: ReadonlyArray<VectorizeVector>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly describe: Effect.Effect<VectorizeIndexInfo$1 | VectorizeIndexDetails$1, VectorizeOperationError>;
+  readonly query: (vector: VectorizeValues, options?: VectorizeQueryOptions$1) => Effect.Effect<VectorizeMatches$1, VectorizeOperationError>;
+  readonly queryById: (vectorId: string, options?: VectorizeQueryOptions$1) => Effect.Effect<VectorizeMatches$1, VectorizeOperationError>;
+  readonly insert: (vectors: ReadonlyArray<VectorizeVector$1>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
+  readonly upsert: (vectors: ReadonlyArray<VectorizeVector$1>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
   readonly deleteByIds: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
   readonly delete: (ids: ReadonlyArray<string>) => Effect.Effect<VectorizeMutation, VectorizeOperationError>;
-  readonly getByIds: (ids: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<VectorizeVector>, VectorizeOperationError>;
+  readonly getByIds: (ids: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<VectorizeVector$1>, VectorizeOperationError>;
   readonly rawUnsafe: Effect.Effect<VectorizeBinding>;
   readonly definition: VectorizeDefinition;
 }
@@ -65,4 +66,4 @@ declare const layer: <Self>(tag: Context$1.Service<Self, VectorizeClient>, defin
 declare const make: <Id extends string>(id: Id) => TagClass<VectorizeService<Id>, Id>;
 declare const Tag: <Self>() => <Id extends string>(id: Id) => TagClass<Self, Id>;
 //#endregion
-export { type BindingNotFoundError, type BindingValidationError, LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails, VectorizeIndexInfo, VectorizeMatch, VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector, VectorizeVectorMetadata, VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue, Vectorize_d_exports, isVectorizeBinding, layer, make, makeClient };
+export { type BindingNotFoundError, type BindingValidationError, LayerOptions, Tag, TagClass, VectorizeBinding, VectorizeClient, VectorizeDefinition, VectorizeIndexDetails$1 as VectorizeIndexDetails, VectorizeIndexInfo$1 as VectorizeIndexInfo, VectorizeMatch$1 as VectorizeMatch, VectorizeMatches$1 as VectorizeMatches, VectorizeMutation, VectorizeOperation, VectorizeOperationError, VectorizeQueryOptions$1 as VectorizeQueryOptions, VectorizeService, VectorizeValues, VectorizeVector$1 as VectorizeVector, VectorizeVectorMetadata$1 as VectorizeVectorMetadata, VectorizeVectorMetadataFilter$1 as VectorizeVectorMetadataFilter, VectorizeVectorMetadataValue$1 as VectorizeVectorMetadataValue, Vectorize_d_exports, isVectorizeBinding, layer, make, makeClient };

package/dist/WebTransport.d.mts

@@ -1,6 +1,7 @@
 import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import * as Option from "effect/Option";
+import { Request } from "@cloudflare/workers-types";
 declare namespace WebTransport_d_exports {
   export { Capabilities, InboundTransport, WebTransportCapability, WebTransportUnsupportedError, capabilities, inboundSessionsUnsupported, inboundTransport, isHttp3 };
 }
@@ -26,7 +27,7 @@ declare class InboundTransport extends InboundTransport_base {}
  * dev` or when a Worker invokes another Worker directly) or does not match
  * the expected shape.
  */
-declare const inboundTransport: (request: Pick<CloudflareRequest, "cf">) => Option.Option<InboundTransport>;
+declare const inboundTransport: (request: Pick<Request, "cf">) => Option.Option<InboundTransport>;
 declare const isHttp3: (transport: InboundTransport) => boolean;
 interface Capabilities {
   /**

package/dist/WorkersAi.d.mts

@@ -3,6 +3,7 @@ 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 { Ai, AiAsyncBatchResponse, AiGateway, AiModelListType, AiModels, AiModelsSearchObject, AiModelsSearchParams, AiOptions, AiTextEmbeddingsInput, Ai_Cf_Qwen_Qwen3_Embedding_0_6B_Input } from "@cloudflare/workers-types";
 import { Layer } from "effect";
 declare namespace WorkersAi_d_exports {
   export { BindingNotFoundError, BindingValidationError, LayerOptions, Tag, TagClass, WorkersAiAsyncBatchResponse, WorkersAiBinding, WorkersAiClient, WorkersAiDefinition, WorkersAiEmbeddingInput, WorkersAiEmbeddingResponse, WorkersAiModelsSearchObject, WorkersAiModelsSearchParams, WorkersAiOperationError, WorkersAiOptions, WorkersAiService, embeddingResponse, isWorkersAiBinding, layer, make, makeClient };
@@ -20,7 +21,7 @@ declare class WorkersAiOperationError extends WorkersAiOperationError_base<{
 interface WorkersAiDefinition {
   readonly binding: string;
 }
-type WorkersAiBinding<ModelList extends AiModelListType = AiModels> = CloudflareAi<ModelList>;
+type WorkersAiBinding<ModelList extends AiModelListType = AiModels> = Ai<ModelList>;
 type WorkersAiOptions = AiOptions;
 type WorkersAiModelsSearchParams = AiModelsSearchParams;
 type WorkersAiModelsSearchObject = AiModelsSearchObject;
@@ -53,7 +54,7 @@ interface WorkersAiClient<ModelList extends AiModelListType = AiModels> {
   };
   readonly runEmbedding: <Input extends WorkersAiEmbeddingInput>(model: string, input: Input, options?: WorkersAiOptions) => Effect.Effect<WorkersAiEmbeddingResponse, WorkersAiOperationError>;
   readonly models: (params?: WorkersAiModelsSearchParams) => Effect.Effect<ReadonlyArray<WorkersAiModelsSearchObject>, WorkersAiOperationError>;
-  readonly gateway: (gatewayId: string) => Effect.Effect<CloudflareAiGateway, WorkersAiOperationError>;
+  readonly gateway: (gatewayId: string) => Effect.Effect<AiGateway, WorkersAiOperationError>;
   readonly rawUnsafe: Effect.Effect<WorkersAiBinding<ModelList>>;
   readonly definition: WorkersAiDefinition;
 }

package/dist/WorkflowBinding.d.mts

@@ -4,18 +4,19 @@ import { ServiceFreeSchema } from "./RpcDefinition.mjs";
 import * as Effect from "effect/Effect";
 import * as S from "effect/Schema";
 import * as Option from "effect/Option";
+import { InstanceStatus, Workflow, WorkflowInstance, WorkflowInstanceCreateOptions, WorkflowInstanceLocationHint, WorkflowInstanceRestartOptions, WorkflowInstanceTerminateOptions } from "@cloudflare/workers-types";
 import { Context } from "effect";
 declare namespace WorkflowBinding_d_exports {
-  export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceLocationHint, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowInstanceTerminateOptions, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
+  export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowInstance$1 as WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions$1 as WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceLocationHint$1 as WorkflowInstanceLocationHint, WorkflowInstanceRestartOptions$1 as WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowInstanceTerminateOptions$1 as WorkflowInstanceTerminateOptions, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
 }
-type WorkflowInstanceCreateOptions<Payload> = Omit<CloudflareWorkflowInstanceCreateOptions<Payload>, "params">;
+type WorkflowInstanceCreateOptions$1<Payload> = Omit<WorkflowInstanceCreateOptions<Payload>, "params">;
 type WorkflowInstanceCreateBatchOptions<Payload, EncodedPayload = unknown> = ReadonlyArray<{
   readonly payload: Payload;
-} & WorkflowInstanceCreateOptions<EncodedPayload>>;
-type WorkflowInstanceRestartOptions = CloudflareWorkflowInstanceRestartOptions;
-type WorkflowInstanceTerminateOptions = CloudflareWorkflowInstanceTerminateOptions;
-type WorkflowInstanceLocationHint = CloudflareWorkflowInstanceLocationHint;
-type WorkflowInstanceStatusName = CloudflareInstanceStatus["status"];
+} & WorkflowInstanceCreateOptions$1<EncodedPayload>>;
+type WorkflowInstanceRestartOptions$1 = WorkflowInstanceRestartOptions;
+type WorkflowInstanceTerminateOptions$1 = WorkflowInstanceTerminateOptions;
+type WorkflowInstanceLocationHint$1 = WorkflowInstanceLocationHint;
+type WorkflowInstanceStatusName = InstanceStatus["status"];
 interface WorkflowInstanceStatus<Result> {
   readonly status: WorkflowInstanceStatusName;
   readonly output: Option.Option<Result>;
@@ -24,13 +25,13 @@ interface WorkflowInstanceStatus<Result> {
     readonly message: string;
   }>;
 }
-interface WorkflowInstance<Result> {
-  readonly raw: CloudflareWorkflowInstance;
+interface WorkflowInstance$1<Result> {
+  readonly raw: WorkflowInstance;
   readonly id: string;
   readonly pause: Effect.Effect<void, WorkflowOperationError>;
   readonly resume: Effect.Effect<void, WorkflowOperationError>;
-  readonly terminate: (options?: WorkflowInstanceTerminateOptions) => Effect.Effect<void, WorkflowOperationError>;
-  readonly restart: (options?: WorkflowInstanceRestartOptions) => Effect.Effect<void, WorkflowOperationError>;
+  readonly terminate: (options?: WorkflowInstanceTerminateOptions$1) => Effect.Effect<void, WorkflowOperationError>;
+  readonly restart: (options?: WorkflowInstanceRestartOptions$1) => Effect.Effect<void, WorkflowOperationError>;
   readonly delete: Effect.Effect<void, WorkflowOperationError>;
   readonly status: Effect.Effect<WorkflowInstanceStatus<Result>, WorkflowOperationError | WorkflowResultDecodeError>;
   readonly sendEvent: (event: WorkflowInstanceEvent) => Effect.Effect<void, WorkflowOperationError>;
@@ -45,10 +46,10 @@ interface WorkflowBindingDefinition<Payload extends ServiceFreeSchema, Result ex
   readonly result: Result;
 }
 interface WorkflowBindingClient<Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema> {
-  readonly create: (payload: S.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions<S.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError | S.SchemaError>;
-  readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<S.Schema.Type<Payload>, S.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance<S.Schema.Type<Result>>>, WorkflowOperationError | S.SchemaError>;
-  readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance<S.Schema.Type<Result>>, WorkflowOperationError>;
-  readonly rawUnsafe: Effect.Effect<CloudflareWorkflow<S.Codec.Encoded<Payload>>>;
+  readonly create: (payload: S.Schema.Type<Payload>, options?: WorkflowInstanceCreateOptions$1<S.Codec.Encoded<Payload>>) => Effect.Effect<WorkflowInstance$1<S.Schema.Type<Result>>, WorkflowOperationError | S.SchemaError>;
+  readonly createBatch: (batch: WorkflowInstanceCreateBatchOptions<S.Schema.Type<Payload>, S.Codec.Encoded<Payload>>) => Effect.Effect<ReadonlyArray<WorkflowInstance$1<S.Schema.Type<Result>>>, WorkflowOperationError | S.SchemaError>;
+  readonly get: (instanceId: string) => Effect.Effect<WorkflowInstance$1<S.Schema.Type<Result>>, WorkflowOperationError>;
+  readonly rawUnsafe: Effect.Effect<Workflow<S.Codec.Encoded<Payload>>>;
 }
 declare const WorkflowOperationError_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: "WorkflowOperationError";
@@ -71,8 +72,8 @@ declare class WorkflowResultDecodeError extends WorkflowResultDecodeError_base<{
   get message(): string;
 }
 type WorkflowBindingValue = S.Schema.Type<typeof S.Unknown>;
-declare const isWorkflow: <Payload>(value: WorkflowBindingValue) => value is CloudflareWorkflow<Payload>;
-declare const makeClient: <Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema>(definition: WorkflowBindingDefinition<Payload, Result>) => ((workflow: CloudflareWorkflow<S.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>);
+declare const isWorkflow: <Payload>(value: WorkflowBindingValue) => value is Workflow<Payload>;
+declare const makeClient: <Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema>(definition: WorkflowBindingDefinition<Payload, Result>) => ((workflow: Workflow<S.Codec.Encoded<Payload>>) => WorkflowBindingClient<Payload, Result>);
 declare const layer: <Self, Payload extends ServiceFreeSchema, Result extends ServiceFreeSchema>(tag: Context.Service<Self, WorkflowBindingClient<Payload, Result>>, definition: WorkflowBindingDefinition<Payload, Result>) => import("effect/Layer").Layer<Self, BindingNotFoundError | BindingValidationError, WorkerEnvironment>;
 //#endregion
-export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowBinding_d_exports, WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceLocationHint, WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowInstanceTerminateOptions, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };
+export { WorkflowBindingClient, WorkflowBindingDefinition, WorkflowBinding_d_exports, WorkflowInstance$1 as WorkflowInstance, WorkflowInstanceCreateBatchOptions, WorkflowInstanceCreateOptions$1 as WorkflowInstanceCreateOptions, WorkflowInstanceEvent, WorkflowInstanceLocationHint$1 as WorkflowInstanceLocationHint, WorkflowInstanceRestartOptions$1 as WorkflowInstanceRestartOptions, WorkflowInstanceStatus, WorkflowInstanceStatusName, WorkflowInstanceTerminateOptions$1 as WorkflowInstanceTerminateOptions, WorkflowOperationError, WorkflowResultDecodeError, isWorkflow, layer, makeClient };

package/dist/internal/NativeCallback.mjs

@@ -23,7 +23,7 @@ const runNativeCallback = Effect.fnUntraced(function* (operation) {
 		const runPromise = yield* FiberSet.makeRuntimePromise();
 		return yield* Effect.callback((resume) => {
 			try {
-				nativePromise = operation((effect) => runPromise(Effect.provideContext(Effect.exit(effect), callbackContext)));
+				nativePromise = operation((effect) => runPromise(Effect.provideContext(Effect.exit(effect), callbackContext), { scheduler: callbackScheduler }));
 			} catch (cause) {
 				resume(Effect.fail(cause));
 				return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-cf",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "description": "Effect-native primitives for Cloudflare Workers and bindings.",
   "license": "MIT",
   "repository": {

package/src/Queue.ts

@@ -8,7 +8,7 @@ import type * as QueueDefinition from "./QueueDefinition";
 import * as ErrorMessage from "./internal/ErrorMessage";
 
 export type { BindingNotFoundError, BindingValidationError } from "./Binding";
-export type { QueueOperationError, QueueProducer } from "./QueueBinding";
+export type { MessageSendRequest, QueueOperationError, QueueProducer } from "./QueueBinding";
 
 export interface QueueMessage<Body> {
   readonly raw: globalThis.Message<unknown>;

package/src/QueueDefinition.ts

@@ -12,7 +12,7 @@ import * as WorkerEntrypoint from "./Worker";
 import type * as RpcDefinition from "./RpcDefinition";
 
 export type { BindingNotFoundError, BindingValidationError } from "./Binding";
-export type { QueueOperationError, QueueProducer } from "./QueueBinding";
+export type { MessageSendRequest, QueueOperationError, QueueProducer } from "./QueueBinding";
 
 export interface Definition<
   Id extends string = string,

package/src/internal/NativeCallback.ts

@@ -50,7 +50,9 @@ export const runNativeCallback = Effect.fnUntraced(function* <A, E, R, B>(
       return yield* Effect.callback<B, unknown>((resume) => {
         try {
           nativePromise = operation((effect) =>
-            runPromise(Effect.provideContext(Effect.exit(effect), callbackContext)),
+            runPromise(Effect.provideContext(Effect.exit(effect), callbackContext), {
+              scheduler: callbackScheduler,
+            }),
           );
         } catch (cause) {
           resume(Effect.fail(cause));