@distilled.cloud/aws 0.8.0 → 0.9.0

package/lib/services/codeguru-reviewer.d.ts

@@ -451,7 +451,7 @@ export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
 export interface UntagResourceResponse {
 }
 export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
-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": {
@@ -460,7 +460,7 @@ 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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -469,7 +469,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -478,7 +478,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -487,7 +487,7 @@ declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.Tagg
 });
 export declare class ThrottlingException extends ThrottlingException_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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -496,7 +496,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_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>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -505,7 +505,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const NotFoundException_base: S.ErrorClass<NotFoundException, S.TaggedStruct<"NotFoundException", {
+declare const NotFoundException_base: S.Class<NotFoundException, S.TaggedStruct<"NotFoundException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/codeguru-security.d.ts

@@ -342,7 +342,7 @@ export interface UpdateAccountConfigurationResponse {
     encryptionConfig: EncryptionConfig;
 }
 export declare const UpdateAccountConfigurationResponse: S.Schema<UpdateAccountConfigurationResponse>;
-declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
+declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
     readonly errorCode: S.String;
     readonly message: S.String;
     readonly resourceId: S.optional<S.String>;
@@ -354,7 +354,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly error: S.optional<S.String>;
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
@@ -368,7 +368,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly errorCode: S.String;
     readonly message: S.String;
     readonly serviceCode: S.optional<S.String>;
@@ -384,7 +384,7 @@ declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.Tagg
 });
 export declare class ThrottlingException extends ThrottlingException_base {
 }
-declare const ValidationException_base: S.ErrorClass<ValidationException, S.TaggedStruct<"ValidationException", {
+declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
     readonly errorCode: S.String;
     readonly message: S.String;
     readonly reason: S.String;
@@ -396,7 +396,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedStruct<"ConflictException", {
+declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly errorCode: S.String;
     readonly message: S.String;
     readonly resourceId: S.String;
@@ -408,7 +408,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly errorCode: S.String;
     readonly message: S.String;
     readonly resourceId: S.String;

package/lib/services/codeguruprofiler.d.ts

@@ -467,7 +467,7 @@ export declare const SubmitFeedbackRequest: S.Schema<SubmitFeedbackRequest>;
 export interface SubmitFeedbackResponse {
 }
 export declare const SubmitFeedbackResponse: S.Schema<SubmitFeedbackResponse>;
-declare const InternalServerException_base: S.ErrorClass<InternalServerException, S.TaggedStruct<"InternalServerException", {
+declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -480,7 +480,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -493,7 +493,7 @@ declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.Tagg
 });
 export declare class ThrottlingException extends ThrottlingException_base {
 }
-declare const ValidationException_base: S.ErrorClass<ValidationException, S.TaggedStruct<"ValidationException", {
+declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -502,7 +502,7 @@ declare const ValidationException_base: S.ErrorClass<ValidationException, S.Tagg
 });
 export declare class ValidationException extends ValidationException_base {
 }
-declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
+declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -511,7 +511,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedStruct<"ConflictException", {
+declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -520,7 +520,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const ServiceQuotaExceededException_base: S.ErrorClass<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
+declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
     readonly message: S.String;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {

package/lib/services/codepipeline.d.ts

@@ -1538,135 +1538,135 @@ export interface UpdatePipelineOutput {
     pipeline?: PipelineDeclaration;
 }
 export declare const UpdatePipelineOutput: S.Schema<UpdatePipelineOutput>;
-declare const InvalidNonceException_base: S.ErrorClass<InvalidNonceException, S.TaggedStruct<"InvalidNonceException", {
+declare const InvalidNonceException_base: S.Class<InvalidNonceException, S.TaggedStruct<"InvalidNonceException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidNonceException extends InvalidNonceException_base {
 }
-declare const JobNotFoundException_base: S.ErrorClass<JobNotFoundException, S.TaggedStruct<"JobNotFoundException", {
+declare const JobNotFoundException_base: S.Class<JobNotFoundException, S.TaggedStruct<"JobNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class JobNotFoundException extends JobNotFoundException_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 InvalidClientTokenException_base: S.ErrorClass<InvalidClientTokenException, S.TaggedStruct<"InvalidClientTokenException", {
+declare const InvalidClientTokenException_base: S.Class<InvalidClientTokenException, S.TaggedStruct<"InvalidClientTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidClientTokenException extends InvalidClientTokenException_base {
 }
-declare const ConcurrentModificationException_base: S.ErrorClass<ConcurrentModificationException, S.TaggedStruct<"ConcurrentModificationException", {
+declare const ConcurrentModificationException_base: S.Class<ConcurrentModificationException, S.TaggedStruct<"ConcurrentModificationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ConcurrentModificationException extends ConcurrentModificationException_base {
 }
-declare const InvalidTagsException_base: S.ErrorClass<InvalidTagsException, S.TaggedStruct<"InvalidTagsException", {
+declare const InvalidTagsException_base: S.Class<InvalidTagsException, S.TaggedStruct<"InvalidTagsException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidTagsException extends InvalidTagsException_base {
 }
-declare const LimitExceededException_base: S.ErrorClass<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
+declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class LimitExceededException extends LimitExceededException_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>;
 }>, import("effect/Cause").YieldableError>;
 export declare class TooManyTagsException extends TooManyTagsException_base {
 }
-declare const InvalidActionDeclarationException_base: S.ErrorClass<InvalidActionDeclarationException, S.TaggedStruct<"InvalidActionDeclarationException", {
+declare const InvalidActionDeclarationException_base: S.Class<InvalidActionDeclarationException, S.TaggedStruct<"InvalidActionDeclarationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidActionDeclarationException extends InvalidActionDeclarationException_base {
 }
-declare const InvalidBlockerDeclarationException_base: S.ErrorClass<InvalidBlockerDeclarationException, S.TaggedStruct<"InvalidBlockerDeclarationException", {
+declare const InvalidBlockerDeclarationException_base: S.Class<InvalidBlockerDeclarationException, S.TaggedStruct<"InvalidBlockerDeclarationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidBlockerDeclarationException extends InvalidBlockerDeclarationException_base {
 }
-declare const InvalidStageDeclarationException_base: S.ErrorClass<InvalidStageDeclarationException, S.TaggedStruct<"InvalidStageDeclarationException", {
+declare const InvalidStageDeclarationException_base: S.Class<InvalidStageDeclarationException, S.TaggedStruct<"InvalidStageDeclarationException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidStageDeclarationException extends InvalidStageDeclarationException_base {
 }
-declare const InvalidStructureException_base: S.ErrorClass<InvalidStructureException, S.TaggedStruct<"InvalidStructureException", {
+declare const InvalidStructureException_base: S.Class<InvalidStructureException, S.TaggedStruct<"InvalidStructureException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidStructureException extends InvalidStructureException_base {
 }
-declare const PipelineNameInUseException_base: S.ErrorClass<PipelineNameInUseException, S.TaggedStruct<"PipelineNameInUseException", {
+declare const PipelineNameInUseException_base: S.Class<PipelineNameInUseException, S.TaggedStruct<"PipelineNameInUseException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PipelineNameInUseException extends PipelineNameInUseException_base {
 }
-declare const WebhookNotFoundException_base: S.ErrorClass<WebhookNotFoundException, S.TaggedStruct<"WebhookNotFoundException", {}>, import("effect/Cause").YieldableError>;
+declare const WebhookNotFoundException_base: S.Class<WebhookNotFoundException, S.TaggedStruct<"WebhookNotFoundException", {}>, import("effect/Cause").YieldableError>;
 export declare class WebhookNotFoundException extends WebhookNotFoundException_base {
 }
-declare const PipelineNotFoundException_base: S.ErrorClass<PipelineNotFoundException, S.TaggedStruct<"PipelineNotFoundException", {
+declare const PipelineNotFoundException_base: S.Class<PipelineNotFoundException, S.TaggedStruct<"PipelineNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PipelineNotFoundException extends PipelineNotFoundException_base {
 }
-declare const StageNotFoundException_base: S.ErrorClass<StageNotFoundException, S.TaggedStruct<"StageNotFoundException", {
+declare const StageNotFoundException_base: S.Class<StageNotFoundException, S.TaggedStruct<"StageNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class StageNotFoundException extends StageNotFoundException_base {
 }
-declare const ActionTypeNotFoundException_base: S.ErrorClass<ActionTypeNotFoundException, S.TaggedStruct<"ActionTypeNotFoundException", {
+declare const ActionTypeNotFoundException_base: S.Class<ActionTypeNotFoundException, S.TaggedStruct<"ActionTypeNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ActionTypeNotFoundException extends ActionTypeNotFoundException_base {
 }
-declare const PipelineVersionNotFoundException_base: S.ErrorClass<PipelineVersionNotFoundException, S.TaggedStruct<"PipelineVersionNotFoundException", {
+declare const PipelineVersionNotFoundException_base: S.Class<PipelineVersionNotFoundException, S.TaggedStruct<"PipelineVersionNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PipelineVersionNotFoundException extends PipelineVersionNotFoundException_base {
 }
-declare const PipelineExecutionNotFoundException_base: S.ErrorClass<PipelineExecutionNotFoundException, S.TaggedStruct<"PipelineExecutionNotFoundException", {
+declare const PipelineExecutionNotFoundException_base: S.Class<PipelineExecutionNotFoundException, S.TaggedStruct<"PipelineExecutionNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PipelineExecutionNotFoundException extends PipelineExecutionNotFoundException_base {
 }
-declare const InvalidJobException_base: S.ErrorClass<InvalidJobException, S.TaggedStruct<"InvalidJobException", {
+declare const InvalidJobException_base: S.Class<InvalidJobException, S.TaggedStruct<"InvalidJobException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidJobException extends InvalidJobException_base {
 }
-declare const InvalidNextTokenException_base: S.ErrorClass<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
+declare const InvalidNextTokenException_base: S.Class<InvalidNextTokenException, S.TaggedStruct<"InvalidNextTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidNextTokenException extends InvalidNextTokenException_base {
 }
-declare const ActionExecutionNotFoundException_base: S.ErrorClass<ActionExecutionNotFoundException, S.TaggedStruct<"ActionExecutionNotFoundException", {
+declare const ActionExecutionNotFoundException_base: S.Class<ActionExecutionNotFoundException, S.TaggedStruct<"ActionExecutionNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ActionExecutionNotFoundException extends ActionExecutionNotFoundException_base {
 }
-declare const InvalidArnException_base: S.ErrorClass<InvalidArnException, S.TaggedStruct<"InvalidArnException", {
+declare const InvalidArnException_base: S.Class<InvalidArnException, S.TaggedStruct<"InvalidArnException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidArnException extends InvalidArnException_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>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
-declare const ConcurrentPipelineExecutionsLimitExceededException_base: S.ErrorClass<ConcurrentPipelineExecutionsLimitExceededException, S.TaggedStruct<"ConcurrentPipelineExecutionsLimitExceededException", {
+declare const ConcurrentPipelineExecutionsLimitExceededException_base: S.Class<ConcurrentPipelineExecutionsLimitExceededException, S.TaggedStruct<"ConcurrentPipelineExecutionsLimitExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ConcurrentPipelineExecutionsLimitExceededException extends ConcurrentPipelineExecutionsLimitExceededException_base {
 }
-declare const ConditionNotOverridableException_base: S.ErrorClass<ConditionNotOverridableException, S.TaggedStruct<"ConditionNotOverridableException", {
+declare const ConditionNotOverridableException_base: S.Class<ConditionNotOverridableException, S.TaggedStruct<"ConditionNotOverridableException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ConditionNotOverridableException extends ConditionNotOverridableException_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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -1675,72 +1675,72 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const NotLatestPipelineExecutionException_base: S.ErrorClass<NotLatestPipelineExecutionException, S.TaggedStruct<"NotLatestPipelineExecutionException", {
+declare const NotLatestPipelineExecutionException_base: S.Class<NotLatestPipelineExecutionException, S.TaggedStruct<"NotLatestPipelineExecutionException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class NotLatestPipelineExecutionException extends NotLatestPipelineExecutionException_base {
 }
-declare const ActionNotFoundException_base: S.ErrorClass<ActionNotFoundException, S.TaggedStruct<"ActionNotFoundException", {
+declare const ActionNotFoundException_base: S.Class<ActionNotFoundException, S.TaggedStruct<"ActionNotFoundException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ActionNotFoundException extends ActionNotFoundException_base {
 }
-declare const ApprovalAlreadyCompletedException_base: S.ErrorClass<ApprovalAlreadyCompletedException, S.TaggedStruct<"ApprovalAlreadyCompletedException", {
+declare const ApprovalAlreadyCompletedException_base: S.Class<ApprovalAlreadyCompletedException, S.TaggedStruct<"ApprovalAlreadyCompletedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class ApprovalAlreadyCompletedException extends ApprovalAlreadyCompletedException_base {
 }
-declare const InvalidApprovalTokenException_base: S.ErrorClass<InvalidApprovalTokenException, S.TaggedStruct<"InvalidApprovalTokenException", {
+declare const InvalidApprovalTokenException_base: S.Class<InvalidApprovalTokenException, S.TaggedStruct<"InvalidApprovalTokenException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidApprovalTokenException extends InvalidApprovalTokenException_base {
 }
-declare const InvalidJobStateException_base: S.ErrorClass<InvalidJobStateException, S.TaggedStruct<"InvalidJobStateException", {
+declare const InvalidJobStateException_base: S.Class<InvalidJobStateException, S.TaggedStruct<"InvalidJobStateException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidJobStateException extends InvalidJobStateException_base {
 }
-declare const OutputVariablesSizeExceededException_base: S.ErrorClass<OutputVariablesSizeExceededException, S.TaggedStruct<"OutputVariablesSizeExceededException", {
+declare const OutputVariablesSizeExceededException_base: S.Class<OutputVariablesSizeExceededException, S.TaggedStruct<"OutputVariablesSizeExceededException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class OutputVariablesSizeExceededException extends OutputVariablesSizeExceededException_base {
 }
-declare const InvalidWebhookAuthenticationParametersException_base: S.ErrorClass<InvalidWebhookAuthenticationParametersException, S.TaggedStruct<"InvalidWebhookAuthenticationParametersException", {
+declare const InvalidWebhookAuthenticationParametersException_base: S.Class<InvalidWebhookAuthenticationParametersException, S.TaggedStruct<"InvalidWebhookAuthenticationParametersException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidWebhookAuthenticationParametersException extends InvalidWebhookAuthenticationParametersException_base {
 }
-declare const InvalidWebhookFilterPatternException_base: S.ErrorClass<InvalidWebhookFilterPatternException, S.TaggedStruct<"InvalidWebhookFilterPatternException", {
+declare const InvalidWebhookFilterPatternException_base: S.Class<InvalidWebhookFilterPatternException, S.TaggedStruct<"InvalidWebhookFilterPatternException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class InvalidWebhookFilterPatternException extends InvalidWebhookFilterPatternException_base {
 }
-declare const StageNotRetryableException_base: S.ErrorClass<StageNotRetryableException, S.TaggedStruct<"StageNotRetryableException", {
+declare const StageNotRetryableException_base: S.Class<StageNotRetryableException, S.TaggedStruct<"StageNotRetryableException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class StageNotRetryableException extends StageNotRetryableException_base {
 }
-declare const PipelineExecutionOutdatedException_base: S.ErrorClass<PipelineExecutionOutdatedException, S.TaggedStruct<"PipelineExecutionOutdatedException", {
+declare const PipelineExecutionOutdatedException_base: S.Class<PipelineExecutionOutdatedException, S.TaggedStruct<"PipelineExecutionOutdatedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PipelineExecutionOutdatedException extends PipelineExecutionOutdatedException_base {
 }
-declare const UnableToRollbackStageException_base: S.ErrorClass<UnableToRollbackStageException, S.TaggedStruct<"UnableToRollbackStageException", {
+declare const UnableToRollbackStageException_base: S.Class<UnableToRollbackStageException, S.TaggedStruct<"UnableToRollbackStageException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class UnableToRollbackStageException extends UnableToRollbackStageException_base {
 }
-declare const DuplicatedStopRequestException_base: S.ErrorClass<DuplicatedStopRequestException, S.TaggedStruct<"DuplicatedStopRequestException", {
+declare const DuplicatedStopRequestException_base: S.Class<DuplicatedStopRequestException, S.TaggedStruct<"DuplicatedStopRequestException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class DuplicatedStopRequestException extends DuplicatedStopRequestException_base {
 }
-declare const PipelineExecutionNotStoppableException_base: S.ErrorClass<PipelineExecutionNotStoppableException, S.TaggedStruct<"PipelineExecutionNotStoppableException", {
+declare const PipelineExecutionNotStoppableException_base: S.Class<PipelineExecutionNotStoppableException, S.TaggedStruct<"PipelineExecutionNotStoppableException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class PipelineExecutionNotStoppableException extends PipelineExecutionNotStoppableException_base {
 }
-declare const RequestFailedException_base: S.ErrorClass<RequestFailedException, S.TaggedStruct<"RequestFailedException", {
+declare const RequestFailedException_base: S.Class<RequestFailedException, S.TaggedStruct<"RequestFailedException", {
     readonly message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError>;
 export declare class RequestFailedException extends RequestFailedException_base {

package/lib/services/codestar-connections.d.ts

@@ -484,7 +484,7 @@ export interface UpdateSyncConfigurationOutput {
     SyncConfiguration: SyncConfiguration;
 }
 export declare const UpdateSyncConfigurationOutput: S.Schema<UpdateSyncConfigurationOutput>;
-declare const LimitExceededException_base: S.ErrorClass<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
+declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -493,7 +493,7 @@ declare const LimitExceededException_base: S.ErrorClass<LimitExceededException,
 });
 export declare class LimitExceededException extends LimitExceededException_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>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -502,7 +502,7 @@ declare const ResourceNotFoundException_base: S.ErrorClass<ResourceNotFoundExcep
 });
 export declare class ResourceNotFoundException extends ResourceNotFoundException_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>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -511,7 +511,7 @@ declare const ResourceUnavailableException_base: S.ErrorClass<ResourceUnavailabl
 });
 export declare class ResourceUnavailableException extends ResourceUnavailableException_base {
 }
-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": {
@@ -520,7 +520,7 @@ declare const AccessDeniedException_base: S.ErrorClass<AccessDeniedException, S.
 });
 export declare class AccessDeniedException extends AccessDeniedException_base {
 }
-declare const ConcurrentModificationException_base: S.ErrorClass<ConcurrentModificationException, S.TaggedStruct<"ConcurrentModificationException", {
+declare const ConcurrentModificationException_base: S.Class<ConcurrentModificationException, S.TaggedStruct<"ConcurrentModificationException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -529,7 +529,7 @@ declare const ConcurrentModificationException_base: S.ErrorClass<ConcurrentModif
 });
 export declare class ConcurrentModificationException extends ConcurrentModificationException_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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -538,7 +538,7 @@ declare const InternalServerException_base: S.ErrorClass<InternalServerException
 });
 export declare class InternalServerException extends InternalServerException_base {
 }
-declare const InvalidInputException_base: S.ErrorClass<InvalidInputException, S.TaggedStruct<"InvalidInputException", {
+declare const InvalidInputException_base: S.Class<InvalidInputException, S.TaggedStruct<"InvalidInputException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -547,7 +547,7 @@ declare const InvalidInputException_base: S.ErrorClass<InvalidInputException, S.
 });
 export declare class InvalidInputException extends InvalidInputException_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": {
@@ -560,7 +560,7 @@ declare const ResourceAlreadyExistsException_base: S.ErrorClass<ResourceAlreadyE
 });
 export declare class ResourceAlreadyExistsException extends ResourceAlreadyExistsException_base {
 }
-declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
+declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -569,7 +569,7 @@ declare const ThrottlingException_base: S.ErrorClass<ThrottlingException, S.Tagg
 });
 export declare class ThrottlingException extends ThrottlingException_base {
 }
-declare const SyncConfigurationStillExistsException_base: S.ErrorClass<SyncConfigurationStillExistsException, S.TaggedStruct<"SyncConfigurationStillExistsException", {
+declare const SyncConfigurationStillExistsException_base: S.Class<SyncConfigurationStillExistsException, S.TaggedStruct<"SyncConfigurationStillExistsException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -578,7 +578,7 @@ declare const SyncConfigurationStillExistsException_base: S.ErrorClass<SyncConfi
 });
 export declare class SyncConfigurationStillExistsException extends SyncConfigurationStillExistsException_base {
 }
-declare const UnsupportedProviderTypeException_base: S.ErrorClass<UnsupportedProviderTypeException, S.TaggedStruct<"UnsupportedProviderTypeException", {
+declare const UnsupportedProviderTypeException_base: S.Class<UnsupportedProviderTypeException, S.TaggedStruct<"UnsupportedProviderTypeException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -587,7 +587,7 @@ declare const UnsupportedProviderTypeException_base: S.ErrorClass<UnsupportedPro
 });
 export declare class UnsupportedProviderTypeException extends UnsupportedProviderTypeException_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> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -596,7 +596,7 @@ declare const ConflictException_base: S.ErrorClass<ConflictException, S.TaggedSt
 });
 export declare class ConflictException extends ConflictException_base {
 }
-declare const UnsupportedOperationException_base: S.ErrorClass<UnsupportedOperationException, S.TaggedStruct<"UnsupportedOperationException", {
+declare const UnsupportedOperationException_base: S.Class<UnsupportedOperationException, S.TaggedStruct<"UnsupportedOperationException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -605,7 +605,7 @@ declare const UnsupportedOperationException_base: S.ErrorClass<UnsupportedOperat
 });
 export declare class UnsupportedOperationException extends UnsupportedOperationException_base {
 }
-declare const ConditionalCheckFailedException_base: S.ErrorClass<ConditionalCheckFailedException, S.TaggedStruct<"ConditionalCheckFailedException", {
+declare const ConditionalCheckFailedException_base: S.Class<ConditionalCheckFailedException, S.TaggedStruct<"ConditionalCheckFailedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -614,7 +614,7 @@ declare const ConditionalCheckFailedException_base: S.ErrorClass<ConditionalChec
 });
 export declare class ConditionalCheckFailedException extends ConditionalCheckFailedException_base {
 }
-declare const UpdateOutOfSyncException_base: S.ErrorClass<UpdateOutOfSyncException, S.TaggedStruct<"UpdateOutOfSyncException", {
+declare const UpdateOutOfSyncException_base: S.Class<UpdateOutOfSyncException, S.TaggedStruct<"UpdateOutOfSyncException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -623,7 +623,7 @@ declare const UpdateOutOfSyncException_base: S.ErrorClass<UpdateOutOfSyncExcepti
 });
 export declare class UpdateOutOfSyncException extends UpdateOutOfSyncException_base {
 }
-declare const RetryLatestCommitFailedException_base: S.ErrorClass<RetryLatestCommitFailedException, S.TaggedStruct<"RetryLatestCommitFailedException", {
+declare const RetryLatestCommitFailedException_base: S.Class<RetryLatestCommitFailedException, S.TaggedStruct<"RetryLatestCommitFailedException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {
@@ -632,7 +632,7 @@ declare const RetryLatestCommitFailedException_base: S.ErrorClass<RetryLatestCom
 });
 export declare class RetryLatestCommitFailedException extends RetryLatestCommitFailedException_base {
 }
-declare const SyncBlockerDoesNotExistException_base: S.ErrorClass<SyncBlockerDoesNotExistException, S.TaggedStruct<"SyncBlockerDoesNotExistException", {
+declare const SyncBlockerDoesNotExistException_base: S.Class<SyncBlockerDoesNotExistException, S.TaggedStruct<"SyncBlockerDoesNotExistException", {
     readonly Message: S.optional<S.String>;
 }>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
     "@distilled.cloud/error/categories": {