@distilled.cloud/aws 0.8.0 → 0.9.0

package/lib/services/workspaces.d.ts

@@ -1930,7 +1930,7 @@ export interface UpdateWorkspacesPoolResult {
     WorkspacesPool?: WorkspacesPool;
 }
 export declare const UpdateWorkspacesPoolResult: S.Schema<UpdateWorkspacesPoolResult>;
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1939,66 +1939,66 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedStruct<"ConflictException", {
+declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ConflictException extends ConflictException_base {
 }
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly message: S.optional<S.String>;
     readonly ResourceId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ValidationException_base: S.ErrorClass<ValidationException, S.TaggedStruct<"ValidationException", {
+declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ValidationException extends ValidationException_base {
 }
-declare const InvalidParameterValuesException_base: S.ErrorClass<InvalidParameterValuesException, S.TaggedStruct<"InvalidParameterValuesException", {
+declare const InvalidParameterValuesException_base: S.Class<InvalidParameterValuesException, S.TaggedStruct<"InvalidParameterValuesException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidParameterValuesException extends InvalidParameterValuesException_base {
 }
-declare const InvalidResourceStateException_base: S.ErrorClass<InvalidResourceStateException, S.TaggedStruct<"InvalidResourceStateException", {
+declare const InvalidResourceStateException_base: S.Class<InvalidResourceStateException, S.TaggedStruct<"InvalidResourceStateException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidResourceStateException extends InvalidResourceStateException_base {
 }
-declare const OperationNotSupportedException_base: S.ErrorClass<OperationNotSupportedException, S.TaggedStruct<"OperationNotSupportedException", {
+declare const OperationNotSupportedException_base: S.Class<OperationNotSupportedException, S.TaggedStruct<"OperationNotSupportedException", {
     readonly message: S.optional<S.String>;
     readonly reason: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OperationNotSupportedException extends OperationNotSupportedException_base {
 }
-declare const ResourceAssociatedException_base: S.ErrorClass<ResourceAssociatedException, S.TaggedStruct<"ResourceAssociatedException", {
+declare const ResourceAssociatedException_base: S.Class<ResourceAssociatedException, S.TaggedStruct<"ResourceAssociatedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceAssociatedException extends ResourceAssociatedException_base {
 }
-declare const ResourceLimitExceededException_base: S.ErrorClass<ResourceLimitExceededException, S.TaggedStruct<"ResourceLimitExceededException", {
+declare const ResourceLimitExceededException_base: S.Class<ResourceLimitExceededException, S.TaggedStruct<"ResourceLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceLimitExceededException extends ResourceLimitExceededException_base {
 }
-declare const ApplicationNotSupportedException_base: S.ErrorClass<ApplicationNotSupportedException, S.TaggedStruct<"ApplicationNotSupportedException", {}>, import("effect/Cause").YieldableError>;
+declare const ApplicationNotSupportedException_base: S.Class<ApplicationNotSupportedException, S.TaggedStruct<"ApplicationNotSupportedException", {}>, import("effect/Cause").YieldableError>;
 export declare class ApplicationNotSupportedException extends ApplicationNotSupportedException_base {
 }
-declare const ComputeNotCompatibleException_base: S.ErrorClass<ComputeNotCompatibleException, S.TaggedStruct<"ComputeNotCompatibleException", {}>, import("effect/Cause").YieldableError>;
+declare const ComputeNotCompatibleException_base: S.Class<ComputeNotCompatibleException, S.TaggedStruct<"ComputeNotCompatibleException", {}>, import("effect/Cause").YieldableError>;
 export declare class ComputeNotCompatibleException extends ComputeNotCompatibleException_base {
 }
-declare const IncompatibleApplicationsException_base: S.ErrorClass<IncompatibleApplicationsException, S.TaggedStruct<"IncompatibleApplicationsException", {}>, import("effect/Cause").YieldableError>;
+declare const IncompatibleApplicationsException_base: S.Class<IncompatibleApplicationsException, S.TaggedStruct<"IncompatibleApplicationsException", {}>, import("effect/Cause").YieldableError>;
 export declare class IncompatibleApplicationsException extends IncompatibleApplicationsException_base {
 }
-declare const OperatingSystemNotCompatibleException_base: S.ErrorClass<OperatingSystemNotCompatibleException, S.TaggedStruct<"OperatingSystemNotCompatibleException", {}>, import("effect/Cause").YieldableError>;
+declare const OperatingSystemNotCompatibleException_base: S.Class<OperatingSystemNotCompatibleException, S.TaggedStruct<"OperatingSystemNotCompatibleException", {}>, import("effect/Cause").YieldableError>;
 export declare class OperatingSystemNotCompatibleException extends OperatingSystemNotCompatibleException_base {
 }
-declare const ResourceAlreadyExistsException_base: S.ErrorClass<ResourceAlreadyExistsException, S.TaggedStruct<"ResourceAlreadyExistsException", {
+declare const ResourceAlreadyExistsException_base: S.Class<ResourceAlreadyExistsException, S.TaggedStruct<"ResourceAlreadyExistsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -2007,44 +2007,44 @@ declare const ResourceAlreadyExistsException_base: S.ErrorClass<ResourceAlreadyE
 });
 export declare class ResourceAlreadyExistsException extends ResourceAlreadyExistsException_base {
 }
-declare const ResourceInUseException_base: S.ErrorClass<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
+declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
     readonly message: S.optional<S.String>;
     readonly ResourceId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceInUseException extends ResourceInUseException_base {
 }
-declare const ResourceUnavailableException_base: S.ErrorClass<ResourceUnavailableException, S.TaggedStruct<"ResourceUnavailableException", {
+declare const ResourceUnavailableException_base: S.Class<ResourceUnavailableException, S.TaggedStruct<"ResourceUnavailableException", {
     readonly message: S.optional<S.String>;
     readonly ResourceId: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceUnavailableException extends ResourceUnavailableException_base {
 }
-declare const ResourceCreationFailedException_base: S.ErrorClass<ResourceCreationFailedException, S.TaggedStruct<"ResourceCreationFailedException", {
+declare const ResourceCreationFailedException_base: S.Class<ResourceCreationFailedException, S.TaggedStruct<"ResourceCreationFailedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceCreationFailedException extends ResourceCreationFailedException_base {
 }
-declare const OperationInProgressException_base: S.ErrorClass<OperationInProgressException, S.TaggedStruct<"OperationInProgressException", {
+declare const OperationInProgressException_base: S.Class<OperationInProgressException, S.TaggedStruct<"OperationInProgressException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OperationInProgressException extends OperationInProgressException_base {
 }
-declare const InvalidParameterCombinationException_base: S.ErrorClass<InvalidParameterCombinationException, S.TaggedStruct<"InvalidParameterCombinationException", {
+declare const InvalidParameterCombinationException_base: S.Class<InvalidParameterCombinationException, S.TaggedStruct<"InvalidParameterCombinationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidParameterCombinationException extends InvalidParameterCombinationException_base {
 }
-declare const UnsupportedWorkspaceConfigurationException_base: S.ErrorClass<UnsupportedWorkspaceConfigurationException, S.TaggedStruct<"UnsupportedWorkspaceConfigurationException", {
+declare const UnsupportedWorkspaceConfigurationException_base: S.Class<UnsupportedWorkspaceConfigurationException, S.TaggedStruct<"UnsupportedWorkspaceConfigurationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedWorkspaceConfigurationException extends UnsupportedWorkspaceConfigurationException_base {
 }
-declare const UnsupportedNetworkConfigurationException_base: S.ErrorClass<UnsupportedNetworkConfigurationException, S.TaggedStruct<"UnsupportedNetworkConfigurationException", {
+declare const UnsupportedNetworkConfigurationException_base: S.Class<UnsupportedNetworkConfigurationException, S.TaggedStruct<"UnsupportedNetworkConfigurationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnsupportedNetworkConfigurationException extends UnsupportedNetworkConfigurationException_base {
 }
-declare const WorkspacesDefaultRoleNotFoundException_base: S.ErrorClass<WorkspacesDefaultRoleNotFoundException, S.TaggedStruct<"WorkspacesDefaultRoleNotFoundException", {
+declare const WorkspacesDefaultRoleNotFoundException_base: S.Class<WorkspacesDefaultRoleNotFoundException, S.TaggedStruct<"WorkspacesDefaultRoleNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class WorkspacesDefaultRoleNotFoundException extends WorkspacesDefaultRoleNotFoundException_base {

package/lib/services/xray.d.ts

@@ -1092,12 +1092,12 @@ export interface UpdateTraceSegmentDestinationResult {
     Status?: TraceSegmentDestinationStatus;
 }
 export declare const UpdateTraceSegmentDestinationResult: S.Schema<UpdateTraceSegmentDestinationResult>;
-declare const InvalidRequestException_base: S.ErrorClass<InvalidRequestException, S.TaggedStruct<"InvalidRequestException", {
+declare const InvalidRequestException_base: S.Class<InvalidRequestException, S.TaggedStruct<"InvalidRequestException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidRequestException extends InvalidRequestException_base {
 }
-declare const ThrottledException_base: S.ErrorClass<ThrottledException, S.TaggedStruct<"ThrottledException", {
+declare const ThrottledException_base: S.Class<ThrottledException, S.TaggedStruct<"ThrottledException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1106,7 +1106,7 @@ declare const ThrottledException_base: S.ErrorClass<ThrottledException, S.Tagged
 });
 export declare class ThrottledException extends ThrottledException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly Message: S.optional<S.String>;
     readonly ResourceName: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -1116,12 +1116,12 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const RuleLimitExceededException_base: S.ErrorClass<RuleLimitExceededException, S.TaggedStruct<"RuleLimitExceededException", {
+declare const RuleLimitExceededException_base: S.Class<RuleLimitExceededException, S.TaggedStruct<"RuleLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RuleLimitExceededException extends RuleLimitExceededException_base {
 }
-declare const InvalidPolicyRevisionIdException_base: S.ErrorClass<InvalidPolicyRevisionIdException, S.TaggedStruct<"InvalidPolicyRevisionIdException", {
+declare const InvalidPolicyRevisionIdException_base: S.Class<InvalidPolicyRevisionIdException, S.TaggedStruct<"InvalidPolicyRevisionIdException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1130,7 +1130,7 @@ declare const InvalidPolicyRevisionIdException_base: S.ErrorClass<InvalidPolicyR
 });
 export declare class InvalidPolicyRevisionIdException extends InvalidPolicyRevisionIdException_base {
 }
-declare const LockoutPreventionException_base: S.ErrorClass<LockoutPreventionException, S.TaggedStruct<"LockoutPreventionException", {
+declare const LockoutPreventionException_base: S.Class<LockoutPreventionException, S.TaggedStruct<"LockoutPreventionException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1139,7 +1139,7 @@ declare const LockoutPreventionException_base: S.ErrorClass<LockoutPreventionExc
 });
 export declare class LockoutPreventionException extends LockoutPreventionException_base {
 }
-declare const MalformedPolicyDocumentException_base: S.ErrorClass<MalformedPolicyDocumentException, S.TaggedStruct<"MalformedPolicyDocumentException", {
+declare const MalformedPolicyDocumentException_base: S.Class<MalformedPolicyDocumentException, S.TaggedStruct<"MalformedPolicyDocumentException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1148,7 +1148,7 @@ declare const MalformedPolicyDocumentException_base: S.ErrorClass<MalformedPolic
 });
 export declare class MalformedPolicyDocumentException extends MalformedPolicyDocumentException_base {
 }
-declare const PolicyCountLimitExceededException_base: S.ErrorClass<PolicyCountLimitExceededException, S.TaggedStruct<"PolicyCountLimitExceededException", {
+declare const PolicyCountLimitExceededException_base: S.Class<PolicyCountLimitExceededException, S.TaggedStruct<"PolicyCountLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1157,7 +1157,7 @@ declare const PolicyCountLimitExceededException_base: S.ErrorClass<PolicyCountLi
 });
 export declare class PolicyCountLimitExceededException extends PolicyCountLimitExceededException_base {
 }
-declare const PolicySizeLimitExceededException_base: S.ErrorClass<PolicySizeLimitExceededException, S.TaggedStruct<"PolicySizeLimitExceededException", {
+declare const PolicySizeLimitExceededException_base: S.Class<PolicySizeLimitExceededException, S.TaggedStruct<"PolicySizeLimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1166,7 +1166,7 @@ declare const PolicySizeLimitExceededException_base: S.ErrorClass<PolicySizeLimi
 });
 export declare class PolicySizeLimitExceededException extends PolicySizeLimitExceededException_base {
 }
-declare const TooManyTagsException_base: S.ErrorClass<TooManyTagsException, S.TaggedStruct<"TooManyTagsException", {
+declare const TooManyTagsException_base: S.Class<TooManyTagsException, S.TaggedStruct<"TooManyTagsException", {
     readonly Message: S.optional<S.String>;
     readonly ResourceName: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@distilled.cloud/aws",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/alchemy-run/distilled",
@@ -82,18 +82,18 @@
     "@aws-crypto/util": "^5.2.0",
     "@aws-sdk/credential-providers": "^3.994.0",
     "@aws-sdk/types": "^3.973.1",
-    "@distilled.cloud/core": "0.8.0",
+    "@distilled.cloud/core": "0.9.0",
     "@smithy/shared-ini-file-loader": "^4.4.3",
     "@smithy/types": "^4.12.0",
     "@smithy/util-base64": "^4.3.0",
     "aws4fetch": "^1.0.20",
-    "effect": "4.0.0-beta.43",
+    "effect": "4.0.0-beta.46",
     "fast-xml-parser": "^5.3.2"
   },
   "devDependencies": {
-    "@effect/platform-bun": "4.0.0-beta.43",
-    "@effect/platform-node": "4.0.0-beta.43",
-    "@effect/vitest": "4.0.0-beta.43",
+    "@effect/platform-bun": "4.0.0-beta.46",
+    "@effect/platform-node": "4.0.0-beta.46",
+    "@effect/vitest": "4.0.0-beta.46",
     "@types/bun": "^1.3.0",
     "@types/node": "^25.3.5",
     "archiver": "^7.0.1",
@@ -102,6 +102,6 @@
     "vitest": "^3.2.3"
   },
   "peerDependencies": {
-    "effect": "4.0.0-beta.43"
+    "effect": "4.0.0-beta.46"
   }
 }

package/src/auth.ts

@@ -5,7 +5,7 @@ import * as FileSystem from "effect/FileSystem";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Redacted from "effect/Redacted";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import * as HttpClient from "effect/unstable/http/HttpClient";
 import { createHash } from "node:crypto";
 import {
@@ -30,7 +30,7 @@ const EXPIRE_WINDOW_MS = 5 * 60 * 1000;
 
 const REFRESH_MESSAGE = `To refresh this SSO session run 'aws sso login' with the corresponding profile.`;
 
-export class Auth extends ServiceMap.Service<
+export class Auth extends Context.Service<
   Auth,
   {
     loadProfile: (

package/src/client/api.ts

@@ -325,9 +325,9 @@ export const make = <Op extends Operation<any, any, any>>(
     },
     asEffect() {
       return Effect.map(
-        Effect.services(),
-        (sm) => (input: Operation.Input<Op>) =>
-          outerFn(input).pipe(Effect.provide(sm)),
+        Effect.context(),
+        (context) => (input: Operation.Input<Op>) =>
+          Effect.provideContext(outerFn(input), context),
       );
     },
   };

package/src/credentials.ts

@@ -17,7 +17,7 @@ import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import type { PlatformError } from "effect/PlatformError";
 import * as Redacted from "effect/Redacted";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import type { HttpClientError } from "effect/unstable/http/HttpClientError";
 import { Auth } from "./auth.ts";
 export * as AWSTypes from "@aws-sdk/types";
@@ -56,7 +56,7 @@ export type CredentialsError =
   | HttpClientError
   | PlatformError;
 
-export class Credentials extends ServiceMap.Service<
+export class Credentials extends Context.Service<
   Credentials,
   Effect.Effect<ResolvedCredentials, CredentialsError>
 >()("AWS::Credentials") {}
@@ -217,10 +217,10 @@ export const fromTokenFile = () =>
 
 export const ssoRegion = (region: string) => Layer.succeed(SsoRegion, region);
 
-export class SsoRegion extends ServiceMap.Service<SsoRegion, string>()(
+export class SsoRegion extends Context.Service<SsoRegion, string>()(
   "AWS::SsoRegion",
 ) {}
-export class SsoStartUrl extends ServiceMap.Service<SsoStartUrl, string>()(
+export class SsoStartUrl extends Context.Service<SsoStartUrl, string>()(
   "AWS::SsoStartUrl",
 ) {}
 

package/src/endpoint.ts

@@ -1,5 +1,5 @@
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 
-export class Endpoint extends ServiceMap.Service<Endpoint, string>()(
+export class Endpoint extends Context.Service<Endpoint, string>()(
   "AWS::Endpoint",
 ) {}

package/src/region.ts

@@ -1,8 +1,8 @@
 import * as Config from "effect/Config";
 import * as Layer from "effect/Layer";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 
-export class Region extends ServiceMap.Service<Region, RegionName>()(
+export class Region extends Context.Service<Region, RegionName>()(
   "AWS::Region",
 ) {}
 

package/src/retry.ts

@@ -4,7 +4,7 @@ import { pipe } from "effect/Function";
 import * as Layer from "effect/Layer";
 import * as Ref from "effect/Ref";
 import * as Schedule from "effect/Schedule";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import {
   isRetryable,
   isThrottlingError,
@@ -39,7 +39,7 @@ export type Policy = Options | Factory;
 /**
  * Context tag for configuring retry behavior of AWS API calls.
  */
-export class Retry extends ServiceMap.Service<Retry, Policy>()("AWS::Retry") {}
+export class Retry extends Context.Service<Retry, Policy>()("AWS::Retry") {}
 
 /**
  * Provides a custom retry policy to all AWS API calls in the effect.