@distilled.cloud/cloudflare 0.8.0 → 0.10.0

package/lib/services/api-gateway.d.ts

@@ -9,25 +9,25 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const InvalidObjectIdentifier_base: Schema.ErrorClass<InvalidObjectIdentifier, Schema.TaggedStruct<"InvalidObjectIdentifier", {
+declare const InvalidObjectIdentifier_base: Schema.Class<InvalidObjectIdentifier, Schema.TaggedStruct<"InvalidObjectIdentifier", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidObjectIdentifier extends InvalidObjectIdentifier_base {
 }
-declare const NotEntitled_base: Schema.ErrorClass<NotEntitled, Schema.TaggedStruct<"NotEntitled", {
+declare const NotEntitled_base: Schema.Class<NotEntitled, Schema.TaggedStruct<"NotEntitled", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class NotEntitled extends NotEntitled_base {
 }
-declare const OperationNotFound_base: Schema.ErrorClass<OperationNotFound, Schema.TaggedStruct<"OperationNotFound", {
+declare const OperationNotFound_base: Schema.Class<OperationNotFound, Schema.TaggedStruct<"OperationNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class OperationNotFound extends OperationNotFound_base {
 }
-declare const SchemaNotFound_base: Schema.ErrorClass<SchemaNotFound, Schema.TaggedStruct<"SchemaNotFound", {
+declare const SchemaNotFound_base: Schema.Class<SchemaNotFound, Schema.TaggedStruct<"SchemaNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/argo.d.ts

@@ -9,13 +9,13 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const InvalidObjectIdentifier_base: Schema.ErrorClass<InvalidObjectIdentifier, Schema.TaggedStruct<"InvalidObjectIdentifier", {
+declare const InvalidObjectIdentifier_base: Schema.Class<InvalidObjectIdentifier, Schema.TaggedStruct<"InvalidObjectIdentifier", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidObjectIdentifier extends InvalidObjectIdentifier_base {
 }
-declare const NotAuthorized_base: Schema.ErrorClass<NotAuthorized, Schema.TaggedStruct<"NotAuthorized", {
+declare const NotAuthorized_base: Schema.Class<NotAuthorized, Schema.TaggedStruct<"NotAuthorized", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/containers.d.ts

@@ -9,25 +9,25 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const ContainerApplicationNotFound_base: Schema.ErrorClass<ContainerApplicationNotFound, Schema.TaggedStruct<"ContainerApplicationNotFound", {
+declare const ContainerApplicationNotFound_base: Schema.Class<ContainerApplicationNotFound, Schema.TaggedStruct<"ContainerApplicationNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class ContainerApplicationNotFound extends ContainerApplicationNotFound_base {
 }
-declare const DurableObjectAlreadyHasApplication_base: Schema.ErrorClass<DurableObjectAlreadyHasApplication, Schema.TaggedStruct<"DurableObjectAlreadyHasApplication", {
+declare const DurableObjectAlreadyHasApplication_base: Schema.Class<DurableObjectAlreadyHasApplication, Schema.TaggedStruct<"DurableObjectAlreadyHasApplication", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class DurableObjectAlreadyHasApplication extends DurableObjectAlreadyHasApplication_base {
 }
-declare const DurableObjectNotContainerEnabled_base: Schema.ErrorClass<DurableObjectNotContainerEnabled, Schema.TaggedStruct<"DurableObjectNotContainerEnabled", {
+declare const DurableObjectNotContainerEnabled_base: Schema.Class<DurableObjectNotContainerEnabled, Schema.TaggedStruct<"DurableObjectNotContainerEnabled", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class DurableObjectNotContainerEnabled extends DurableObjectNotContainerEnabled_base {
 }
-declare const InvalidRoute_base: Schema.ErrorClass<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
+declare const InvalidRoute_base: Schema.Class<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/d1.d.ts

@@ -9,49 +9,49 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const DatabaseNotFound_base: Schema.ErrorClass<DatabaseNotFound, Schema.TaggedStruct<"DatabaseNotFound", {
+declare const DatabaseNotFound_base: Schema.Class<DatabaseNotFound, Schema.TaggedStruct<"DatabaseNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class DatabaseNotFound extends DatabaseNotFound_base {
 }
-declare const InternalError_base: Schema.ErrorClass<InternalError, Schema.TaggedStruct<"InternalError", {
+declare const InternalError_base: Schema.Class<InternalError, Schema.TaggedStruct<"InternalError", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InternalError extends InternalError_base {
 }
-declare const InvalidObjectIdentifier_base: Schema.ErrorClass<InvalidObjectIdentifier, Schema.TaggedStruct<"InvalidObjectIdentifier", {
+declare const InvalidObjectIdentifier_base: Schema.Class<InvalidObjectIdentifier, Schema.TaggedStruct<"InvalidObjectIdentifier", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidObjectIdentifier extends InvalidObjectIdentifier_base {
 }
-declare const InvalidProperty_base: Schema.ErrorClass<InvalidProperty, Schema.TaggedStruct<"InvalidProperty", {
+declare const InvalidProperty_base: Schema.Class<InvalidProperty, Schema.TaggedStruct<"InvalidProperty", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidProperty extends InvalidProperty_base {
 }
-declare const InvalidRequest_base: Schema.ErrorClass<InvalidRequest, Schema.TaggedStruct<"InvalidRequest", {
+declare const InvalidRequest_base: Schema.Class<InvalidRequest, Schema.TaggedStruct<"InvalidRequest", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRequest extends InvalidRequest_base {
 }
-declare const NoHistoryAvailable_base: Schema.ErrorClass<NoHistoryAvailable, Schema.TaggedStruct<"NoHistoryAvailable", {
+declare const NoHistoryAvailable_base: Schema.Class<NoHistoryAvailable, Schema.TaggedStruct<"NoHistoryAvailable", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoHistoryAvailable extends NoHistoryAvailable_base {
 }
-declare const TimestampTooOld_base: Schema.ErrorClass<TimestampTooOld, Schema.TaggedStruct<"TimestampTooOld", {
+declare const TimestampTooOld_base: Schema.Class<TimestampTooOld, Schema.TaggedStruct<"TimestampTooOld", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class TimestampTooOld extends TimestampTooOld_base {
 }
-declare const UnknownError_base: Schema.ErrorClass<UnknownError, Schema.TaggedStruct<"UnknownError", {
+declare const UnknownError_base: Schema.Class<UnknownError, Schema.TaggedStruct<"UnknownError", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/durable-objects.d.ts

@@ -9,19 +9,19 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const InvalidIdentifier_base: Schema.ErrorClass<InvalidIdentifier, Schema.TaggedStruct<"InvalidIdentifier", {
+declare const InvalidIdentifier_base: Schema.Class<InvalidIdentifier, Schema.TaggedStruct<"InvalidIdentifier", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidIdentifier extends InvalidIdentifier_base {
 }
-declare const MalformedParameter_base: Schema.ErrorClass<MalformedParameter, Schema.TaggedStruct<"MalformedParameter", {
+declare const MalformedParameter_base: Schema.Class<MalformedParameter, Schema.TaggedStruct<"MalformedParameter", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class MalformedParameter extends MalformedParameter_base {
 }
-declare const NamespaceNotFound_base: Schema.ErrorClass<NamespaceNotFound, Schema.TaggedStruct<"NamespaceNotFound", {
+declare const NamespaceNotFound_base: Schema.Class<NamespaceNotFound, Schema.TaggedStruct<"NamespaceNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/hyperdrive.d.ts

@@ -9,31 +9,31 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const HyperdriveConfigNotFound_base: Schema.ErrorClass<HyperdriveConfigNotFound, Schema.TaggedStruct<"HyperdriveConfigNotFound", {
+declare const HyperdriveConfigNotFound_base: Schema.Class<HyperdriveConfigNotFound, Schema.TaggedStruct<"HyperdriveConfigNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class HyperdriveConfigNotFound extends HyperdriveConfigNotFound_base {
 }
-declare const InvalidHyperdriveConfig_base: Schema.ErrorClass<InvalidHyperdriveConfig, Schema.TaggedStruct<"InvalidHyperdriveConfig", {
+declare const InvalidHyperdriveConfig_base: Schema.Class<InvalidHyperdriveConfig, Schema.TaggedStruct<"InvalidHyperdriveConfig", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidHyperdriveConfig extends InvalidHyperdriveConfig_base {
 }
-declare const InvalidObjectIdentifier_base: Schema.ErrorClass<InvalidObjectIdentifier, Schema.TaggedStruct<"InvalidObjectIdentifier", {
+declare const InvalidObjectIdentifier_base: Schema.Class<InvalidObjectIdentifier, Schema.TaggedStruct<"InvalidObjectIdentifier", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidObjectIdentifier extends InvalidObjectIdentifier_base {
 }
-declare const MethodNotAllowed_base: Schema.ErrorClass<MethodNotAllowed, Schema.TaggedStruct<"MethodNotAllowed", {
+declare const MethodNotAllowed_base: Schema.Class<MethodNotAllowed, Schema.TaggedStruct<"MethodNotAllowed", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class MethodNotAllowed extends MethodNotAllowed_base {
 }
-declare const PrivateHostNotAllowed_base: Schema.ErrorClass<PrivateHostNotAllowed, Schema.TaggedStruct<"PrivateHostNotAllowed", {
+declare const PrivateHostNotAllowed_base: Schema.Class<PrivateHostNotAllowed, Schema.TaggedStruct<"PrivateHostNotAllowed", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/iam.d.ts

@@ -9,7 +9,7 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const InvalidMember_base: Schema.ErrorClass<InvalidMember, Schema.TaggedStruct<"InvalidMember", {
+declare const InvalidMember_base: Schema.Class<InvalidMember, Schema.TaggedStruct<"InvalidMember", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/images.d.ts

@@ -9,43 +9,43 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const ImageAlreadyExists_base: Schema.ErrorClass<ImageAlreadyExists, Schema.TaggedStruct<"ImageAlreadyExists", {
+declare const ImageAlreadyExists_base: Schema.Class<ImageAlreadyExists, Schema.TaggedStruct<"ImageAlreadyExists", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class ImageAlreadyExists extends ImageAlreadyExists_base {
 }
-declare const ImageNotFound_base: Schema.ErrorClass<ImageNotFound, Schema.TaggedStruct<"ImageNotFound", {
+declare const ImageNotFound_base: Schema.Class<ImageNotFound, Schema.TaggedStruct<"ImageNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class ImageNotFound extends ImageNotFound_base {
 }
-declare const ImagesAccessNotEnabled_base: Schema.ErrorClass<ImagesAccessNotEnabled, Schema.TaggedStruct<"ImagesAccessNotEnabled", {
+declare const ImagesAccessNotEnabled_base: Schema.Class<ImagesAccessNotEnabled, Schema.TaggedStruct<"ImagesAccessNotEnabled", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class ImagesAccessNotEnabled extends ImagesAccessNotEnabled_base {
 }
-declare const InvalidUploadFormat_base: Schema.ErrorClass<InvalidUploadFormat, Schema.TaggedStruct<"InvalidUploadFormat", {
+declare const InvalidUploadFormat_base: Schema.Class<InvalidUploadFormat, Schema.TaggedStruct<"InvalidUploadFormat", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidUploadFormat extends InvalidUploadFormat_base {
 }
-declare const KeyNotFound_base: Schema.ErrorClass<KeyNotFound, Schema.TaggedStruct<"KeyNotFound", {
+declare const KeyNotFound_base: Schema.Class<KeyNotFound, Schema.TaggedStruct<"KeyNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class KeyNotFound extends KeyNotFound_base {
 }
-declare const VariantNameNotAllowed_base: Schema.ErrorClass<VariantNameNotAllowed, Schema.TaggedStruct<"VariantNameNotAllowed", {
+declare const VariantNameNotAllowed_base: Schema.Class<VariantNameNotAllowed, Schema.TaggedStruct<"VariantNameNotAllowed", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class VariantNameNotAllowed extends VariantNameNotAllowed_base {
 }
-declare const VariantNotFound_base: Schema.ErrorClass<VariantNotFound, Schema.TaggedStruct<"VariantNotFound", {
+declare const VariantNotFound_base: Schema.Class<VariantNotFound, Schema.TaggedStruct<"VariantNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/kv.d.ts

@@ -9,55 +9,55 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const InvalidExpirationTtl_base: Schema.ErrorClass<InvalidExpirationTtl, Schema.TaggedStruct<"InvalidExpirationTtl", {
+declare const InvalidExpirationTtl_base: Schema.Class<InvalidExpirationTtl, Schema.TaggedStruct<"InvalidExpirationTtl", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidExpirationTtl extends InvalidExpirationTtl_base {
 }
-declare const InvalidObjectIdentifier_base: Schema.ErrorClass<InvalidObjectIdentifier, Schema.TaggedStruct<"InvalidObjectIdentifier", {
+declare const InvalidObjectIdentifier_base: Schema.Class<InvalidObjectIdentifier, Schema.TaggedStruct<"InvalidObjectIdentifier", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidObjectIdentifier extends InvalidObjectIdentifier_base {
 }
-declare const InvalidRequestBody_base: Schema.ErrorClass<InvalidRequestBody, Schema.TaggedStruct<"InvalidRequestBody", {
+declare const InvalidRequestBody_base: Schema.Class<InvalidRequestBody, Schema.TaggedStruct<"InvalidRequestBody", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRequestBody extends InvalidRequestBody_base {
 }
-declare const KeyNotFound_base: Schema.ErrorClass<KeyNotFound, Schema.TaggedStruct<"KeyNotFound", {
+declare const KeyNotFound_base: Schema.Class<KeyNotFound, Schema.TaggedStruct<"KeyNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class KeyNotFound extends KeyNotFound_base {
 }
-declare const MethodNotAllowed_base: Schema.ErrorClass<MethodNotAllowed, Schema.TaggedStruct<"MethodNotAllowed", {
+declare const MethodNotAllowed_base: Schema.Class<MethodNotAllowed, Schema.TaggedStruct<"MethodNotAllowed", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class MethodNotAllowed extends MethodNotAllowed_base {
 }
-declare const MinimumKeysRequired_base: Schema.ErrorClass<MinimumKeysRequired, Schema.TaggedStruct<"MinimumKeysRequired", {
+declare const MinimumKeysRequired_base: Schema.Class<MinimumKeysRequired, Schema.TaggedStruct<"MinimumKeysRequired", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class MinimumKeysRequired extends MinimumKeysRequired_base {
 }
-declare const NamespaceNotFound_base: Schema.ErrorClass<NamespaceNotFound, Schema.TaggedStruct<"NamespaceNotFound", {
+declare const NamespaceNotFound_base: Schema.Class<NamespaceNotFound, Schema.TaggedStruct<"NamespaceNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class NamespaceNotFound extends NamespaceNotFound_base {
 }
-declare const NamespaceTitleAlreadyExists_base: Schema.ErrorClass<NamespaceTitleAlreadyExists, Schema.TaggedStruct<"NamespaceTitleAlreadyExists", {
+declare const NamespaceTitleAlreadyExists_base: Schema.Class<NamespaceTitleAlreadyExists, Schema.TaggedStruct<"NamespaceTitleAlreadyExists", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class NamespaceTitleAlreadyExists extends NamespaceTitleAlreadyExists_base {
 }
-declare const TitleRequired_base: Schema.ErrorClass<TitleRequired, Schema.TaggedStruct<"TitleRequired", {
+declare const TitleRequired_base: Schema.Class<TitleRequired, Schema.TaggedStruct<"TitleRequired", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/pipelines.d.ts

@@ -9,49 +9,49 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const InvalidSinkId_base: Schema.ErrorClass<InvalidSinkId, Schema.TaggedStruct<"InvalidSinkId", {
+declare const InvalidSinkId_base: Schema.Class<InvalidSinkId, Schema.TaggedStruct<"InvalidSinkId", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidSinkId extends InvalidSinkId_base {
 }
-declare const InvalidStreamId_base: Schema.ErrorClass<InvalidStreamId, Schema.TaggedStruct<"InvalidStreamId", {
+declare const InvalidStreamId_base: Schema.Class<InvalidStreamId, Schema.TaggedStruct<"InvalidStreamId", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidStreamId extends InvalidStreamId_base {
 }
-declare const InvalidStreamName_base: Schema.ErrorClass<InvalidStreamName, Schema.TaggedStruct<"InvalidStreamName", {
+declare const InvalidStreamName_base: Schema.Class<InvalidStreamName, Schema.TaggedStruct<"InvalidStreamName", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidStreamName extends InvalidStreamName_base {
 }
-declare const PipelineNotExists_base: Schema.ErrorClass<PipelineNotExists, Schema.TaggedStruct<"PipelineNotExists", {
+declare const PipelineNotExists_base: Schema.Class<PipelineNotExists, Schema.TaggedStruct<"PipelineNotExists", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class PipelineNotExists extends PipelineNotExists_base {
 }
-declare const SinkNotFound_base: Schema.ErrorClass<SinkNotFound, Schema.TaggedStruct<"SinkNotFound", {
+declare const SinkNotFound_base: Schema.Class<SinkNotFound, Schema.TaggedStruct<"SinkNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class SinkNotFound extends SinkNotFound_base {
 }
-declare const StreamAlreadyExists_base: Schema.ErrorClass<StreamAlreadyExists, Schema.TaggedStruct<"StreamAlreadyExists", {
+declare const StreamAlreadyExists_base: Schema.Class<StreamAlreadyExists, Schema.TaggedStruct<"StreamAlreadyExists", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class StreamAlreadyExists extends StreamAlreadyExists_base {
 }
-declare const StreamNotFound_base: Schema.ErrorClass<StreamNotFound, Schema.TaggedStruct<"StreamNotFound", {
+declare const StreamNotFound_base: Schema.Class<StreamNotFound, Schema.TaggedStruct<"StreamNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class StreamNotFound extends StreamNotFound_base {
 }
-declare const TableNotFound_base: Schema.ErrorClass<TableNotFound, Schema.TaggedStruct<"TableNotFound", {
+declare const TableNotFound_base: Schema.Class<TableNotFound, Schema.TaggedStruct<"TableNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/queues.d.ts

@@ -9,25 +9,25 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const InvalidMessageBody_base: Schema.ErrorClass<InvalidMessageBody, Schema.TaggedStruct<"InvalidMessageBody", {
+declare const InvalidMessageBody_base: Schema.Class<InvalidMessageBody, Schema.TaggedStruct<"InvalidMessageBody", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidMessageBody extends InvalidMessageBody_base {
 }
-declare const InvalidQueueName_base: Schema.ErrorClass<InvalidQueueName, Schema.TaggedStruct<"InvalidQueueName", {
+declare const InvalidQueueName_base: Schema.Class<InvalidQueueName, Schema.TaggedStruct<"InvalidQueueName", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidQueueName extends InvalidQueueName_base {
 }
-declare const InvalidRequestBody_base: Schema.ErrorClass<InvalidRequestBody, Schema.TaggedStruct<"InvalidRequestBody", {
+declare const InvalidRequestBody_base: Schema.Class<InvalidRequestBody, Schema.TaggedStruct<"InvalidRequestBody", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRequestBody extends InvalidRequestBody_base {
 }
-declare const UnrecognizedEventType_base: Schema.ErrorClass<UnrecognizedEventType, Schema.TaggedStruct<"UnrecognizedEventType", {
+declare const UnrecognizedEventType_base: Schema.Class<UnrecognizedEventType, Schema.TaggedStruct<"UnrecognizedEventType", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/r2-data-catalog.d.ts

@@ -9,37 +9,37 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const InvalidCredential_base: Schema.ErrorClass<InvalidCredential, Schema.TaggedStruct<"InvalidCredential", {
+declare const InvalidCredential_base: Schema.Class<InvalidCredential, Schema.TaggedStruct<"InvalidCredential", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidCredential extends InvalidCredential_base {
 }
-declare const InvalidRoute_base: Schema.ErrorClass<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
+declare const InvalidRoute_base: Schema.Class<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRoute extends InvalidRoute_base {
 }
-declare const NoSuchBucket_base: Schema.ErrorClass<NoSuchBucket, Schema.TaggedStruct<"NoSuchBucket", {
+declare const NoSuchBucket_base: Schema.Class<NoSuchBucket, Schema.TaggedStruct<"NoSuchBucket", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoSuchBucket extends NoSuchBucket_base {
 }
-declare const TableNotFound_base: Schema.ErrorClass<TableNotFound, Schema.TaggedStruct<"TableNotFound", {
+declare const TableNotFound_base: Schema.Class<TableNotFound, Schema.TaggedStruct<"TableNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class TableNotFound extends TableNotFound_base {
 }
-declare const WarehouseInactive_base: Schema.ErrorClass<WarehouseInactive, Schema.TaggedStruct<"WarehouseInactive", {
+declare const WarehouseInactive_base: Schema.Class<WarehouseInactive, Schema.TaggedStruct<"WarehouseInactive", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class WarehouseInactive extends WarehouseInactive_base {
 }
-declare const WarehouseNotFound_base: Schema.ErrorClass<WarehouseNotFound, Schema.TaggedStruct<"WarehouseNotFound", {
+declare const WarehouseNotFound_base: Schema.Class<WarehouseNotFound, Schema.TaggedStruct<"WarehouseNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/r2.d.ts

@@ -9,49 +9,49 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const BucketAlreadyExists_base: Schema.ErrorClass<BucketAlreadyExists, Schema.TaggedStruct<"BucketAlreadyExists", {
+declare const BucketAlreadyExists_base: Schema.Class<BucketAlreadyExists, Schema.TaggedStruct<"BucketAlreadyExists", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class BucketAlreadyExists extends BucketAlreadyExists_base {
 }
-declare const BucketNotFound_base: Schema.ErrorClass<BucketNotFound, Schema.TaggedStruct<"BucketNotFound", {
+declare const BucketNotFound_base: Schema.Class<BucketNotFound, Schema.TaggedStruct<"BucketNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class BucketNotFound extends BucketNotFound_base {
 }
-declare const InvalidBucketName_base: Schema.ErrorClass<InvalidBucketName, Schema.TaggedStruct<"InvalidBucketName", {
+declare const InvalidBucketName_base: Schema.Class<InvalidBucketName, Schema.TaggedStruct<"InvalidBucketName", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidBucketName extends InvalidBucketName_base {
 }
-declare const InvalidRoute_base: Schema.ErrorClass<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
+declare const InvalidRoute_base: Schema.Class<InvalidRoute, Schema.TaggedStruct<"InvalidRoute", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRoute extends InvalidRoute_base {
 }
-declare const NoCorsConfiguration_base: Schema.ErrorClass<NoCorsConfiguration, Schema.TaggedStruct<"NoCorsConfiguration", {
+declare const NoCorsConfiguration_base: Schema.Class<NoCorsConfiguration, Schema.TaggedStruct<"NoCorsConfiguration", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoCorsConfiguration extends NoCorsConfiguration_base {
 }
-declare const NoEventNotificationConfig_base: Schema.ErrorClass<NoEventNotificationConfig, Schema.TaggedStruct<"NoEventNotificationConfig", {
+declare const NoEventNotificationConfig_base: Schema.Class<NoEventNotificationConfig, Schema.TaggedStruct<"NoEventNotificationConfig", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoEventNotificationConfig extends NoEventNotificationConfig_base {
 }
-declare const NoRoute_base: Schema.ErrorClass<NoRoute, Schema.TaggedStruct<"NoRoute", {
+declare const NoRoute_base: Schema.Class<NoRoute, Schema.TaggedStruct<"NoRoute", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class NoRoute extends NoRoute_base {
 }
-declare const NoSuchBucket_base: Schema.ErrorClass<NoSuchBucket, Schema.TaggedStruct<"NoSuchBucket", {
+declare const NoSuchBucket_base: Schema.Class<NoSuchBucket, Schema.TaggedStruct<"NoSuchBucket", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;

package/lib/services/secrets-store.d.ts

@@ -9,61 +9,61 @@ import type * as HttpClient from "effect/unstable/http/HttpClient";
 import * as API from "../client/api.ts";
 import type { Credentials } from "../credentials.ts";
 import { type DefaultErrors } from "../errors.ts";
-declare const InvalidAccountId_base: Schema.ErrorClass<InvalidAccountId, Schema.TaggedStruct<"InvalidAccountId", {
+declare const InvalidAccountId_base: Schema.Class<InvalidAccountId, Schema.TaggedStruct<"InvalidAccountId", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidAccountId extends InvalidAccountId_base {
 }
-declare const InvalidJsonBody_base: Schema.ErrorClass<InvalidJsonBody, Schema.TaggedStruct<"InvalidJsonBody", {
+declare const InvalidJsonBody_base: Schema.Class<InvalidJsonBody, Schema.TaggedStruct<"InvalidJsonBody", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidJsonBody extends InvalidJsonBody_base {
 }
-declare const MaximumStoresExceeded_base: Schema.ErrorClass<MaximumStoresExceeded, Schema.TaggedStruct<"MaximumStoresExceeded", {
+declare const MaximumStoresExceeded_base: Schema.Class<MaximumStoresExceeded, Schema.TaggedStruct<"MaximumStoresExceeded", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class MaximumStoresExceeded extends MaximumStoresExceeded_base {
 }
-declare const NotFound_base: Schema.ErrorClass<NotFound, Schema.TaggedStruct<"NotFound", {
+declare const NotFound_base: Schema.Class<NotFound, Schema.TaggedStruct<"NotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class NotFound extends NotFound_base {
 }
-declare const SecretNameAlreadyExists_base: Schema.ErrorClass<SecretNameAlreadyExists, Schema.TaggedStruct<"SecretNameAlreadyExists", {
+declare const SecretNameAlreadyExists_base: Schema.Class<SecretNameAlreadyExists, Schema.TaggedStruct<"SecretNameAlreadyExists", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class SecretNameAlreadyExists extends SecretNameAlreadyExists_base {
 }
-declare const SecretNameEmpty_base: Schema.ErrorClass<SecretNameEmpty, Schema.TaggedStruct<"SecretNameEmpty", {
+declare const SecretNameEmpty_base: Schema.Class<SecretNameEmpty, Schema.TaggedStruct<"SecretNameEmpty", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class SecretNameEmpty extends SecretNameEmpty_base {
 }
-declare const SecretNotFound_base: Schema.ErrorClass<SecretNotFound, Schema.TaggedStruct<"SecretNotFound", {
+declare const SecretNotFound_base: Schema.Class<SecretNotFound, Schema.TaggedStruct<"SecretNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class SecretNotFound extends SecretNotFound_base {
 }
-declare const SecretScopeInvalid_base: Schema.ErrorClass<SecretScopeInvalid, Schema.TaggedStruct<"SecretScopeInvalid", {
+declare const SecretScopeInvalid_base: Schema.Class<SecretScopeInvalid, Schema.TaggedStruct<"SecretScopeInvalid", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class SecretScopeInvalid extends SecretScopeInvalid_base {
 }
-declare const SecretScopesEmpty_base: Schema.ErrorClass<SecretScopesEmpty, Schema.TaggedStruct<"SecretScopesEmpty", {
+declare const SecretScopesEmpty_base: Schema.Class<SecretScopesEmpty, Schema.TaggedStruct<"SecretScopesEmpty", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;
 export declare class SecretScopesEmpty extends SecretScopesEmpty_base {
 }
-declare const StoreNotFound_base: Schema.ErrorClass<StoreNotFound, Schema.TaggedStruct<"StoreNotFound", {
+declare const StoreNotFound_base: Schema.Class<StoreNotFound, Schema.TaggedStruct<"StoreNotFound", {
     readonly code: Schema.Number;
     readonly message: Schema.String;
 }>, import("effect/Cause").YieldableError>;