@distilled.cloud/aws 0.16.8 → 0.17.0

package/lib/services/ecs.d.ts

@@ -2972,97 +2972,185 @@ export declare class AccessDeniedException extends AccessDeniedException_base {
 }
 declare const ClientException_base: S.Class<ClientException, S.TaggedStruct<"ClientException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class ClientException extends ClientException_base {
 }
 declare const InvalidParameterException_base: S.Class<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class InvalidParameterException extends InvalidParameterException_base {
 }
 declare const ServerException_base: S.Class<ServerException, S.TaggedStruct<"ServerException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ServerError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
+});
 export declare class ServerException extends ServerException_base {
 }
 declare const NamespaceNotFoundException_base: S.Class<NamespaceNotFoundException, S.TaggedStruct<"NamespaceNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class NamespaceNotFoundException extends NamespaceNotFoundException_base {
 }
 declare const ClusterNotFoundException_base: S.Class<ClusterNotFoundException, S.TaggedStruct<"ClusterNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class ClusterNotFoundException extends ClusterNotFoundException_base {
 }
 declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        QuotaError: true;
+    };
+});
 export declare class LimitExceededException extends LimitExceededException_base {
 }
 declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
 }
 declare const UnsupportedFeatureException_base: S.Class<UnsupportedFeatureException, S.TaggedStruct<"UnsupportedFeatureException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class UnsupportedFeatureException extends UnsupportedFeatureException_base {
 }
 declare const UpdateInProgressException_base: S.Class<UpdateInProgressException, S.TaggedStruct<"UpdateInProgressException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
+});
 export declare class UpdateInProgressException extends UpdateInProgressException_base {
 }
 declare const ClusterContainsCapacityProviderException_base: S.Class<ClusterContainsCapacityProviderException, S.TaggedStruct<"ClusterContainsCapacityProviderException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        DependencyViolationError: true;
+    };
+});
 export declare class ClusterContainsCapacityProviderException extends ClusterContainsCapacityProviderException_base {
 }
 declare const ClusterContainsContainerInstancesException_base: S.Class<ClusterContainsContainerInstancesException, S.TaggedStruct<"ClusterContainsContainerInstancesException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        DependencyViolationError: true;
+    };
+});
 export declare class ClusterContainsContainerInstancesException extends ClusterContainsContainerInstancesException_base {
 }
 declare const ClusterContainsServicesException_base: S.Class<ClusterContainsServicesException, S.TaggedStruct<"ClusterContainsServicesException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        DependencyViolationError: true;
+    };
+});
 export declare class ClusterContainsServicesException extends ClusterContainsServicesException_base {
 }
 declare const ClusterContainsTasksException_base: S.Class<ClusterContainsTasksException, S.TaggedStruct<"ClusterContainsTasksException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        DependencyViolationError: true;
+    };
+});
 export declare class ClusterContainsTasksException extends ClusterContainsTasksException_base {
 }
 declare const ResourceInUseException_base: S.Class<ResourceInUseException, S.TaggedStruct<"ResourceInUseException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+}) & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        RetryableError: true;
+    };
+});
 export declare class ResourceInUseException extends ResourceInUseException_base {
 }
 declare const TargetNotConnectedException_base: S.Class<TargetNotConnectedException, S.TaggedStruct<"TargetNotConnectedException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
 export declare class TargetNotConnectedException extends TargetNotConnectedException_base {
 }
 declare const TargetNotFoundException_base: S.Class<TargetNotFoundException, S.TaggedStruct<"TargetNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class TargetNotFoundException extends TargetNotFoundException_base {
 }
 declare const ServiceNotFoundException_base: S.Class<ServiceNotFoundException, S.TaggedStruct<"ServiceNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class ServiceNotFoundException extends ServiceNotFoundException_base {
 }
 declare const AttributeLimitExceededException_base: S.Class<AttributeLimitExceededException, S.TaggedStruct<"AttributeLimitExceededException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        QuotaError: true;
+    };
+});
 export declare class AttributeLimitExceededException extends AttributeLimitExceededException_base {
 }
 declare const MissingVersionException_base: S.Class<MissingVersionException, S.TaggedStruct<"MissingVersionException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class MissingVersionException extends MissingVersionException_base {
 }
 declare const NoUpdateAvailableException_base: S.Class<NoUpdateAvailableException, S.TaggedStruct<"NoUpdateAvailableException", {
@@ -3072,48 +3160,84 @@ export declare class NoUpdateAvailableException extends NoUpdateAvailableExcepti
 }
 declare const PlatformUnknownException_base: S.Class<PlatformUnknownException, S.TaggedStruct<"PlatformUnknownException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class PlatformUnknownException extends PlatformUnknownException_base {
 }
 declare const DaemonNotActiveException_base: S.Class<DaemonNotActiveException, S.TaggedStruct<"DaemonNotActiveException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
 export declare class DaemonNotActiveException extends DaemonNotActiveException_base {
 }
 declare const DaemonNotFoundException_base: S.Class<DaemonNotFoundException, S.TaggedStruct<"DaemonNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class DaemonNotFoundException extends DaemonNotFoundException_base {
 }
 declare const ServiceNotActiveException_base: S.Class<ServiceNotActiveException, S.TaggedStruct<"ServiceNotActiveException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
 export declare class ServiceNotActiveException extends ServiceNotActiveException_base {
 }
 declare const TaskSetNotFoundException_base: S.Class<TaskSetNotFoundException, S.TaggedStruct<"TaskSetNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class TaskSetNotFoundException extends TaskSetNotFoundException_base {
 }
 declare const PlatformTaskDefinitionIncompatibilityException_base: S.Class<PlatformTaskDefinitionIncompatibilityException, S.TaggedStruct<"PlatformTaskDefinitionIncompatibilityException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class PlatformTaskDefinitionIncompatibilityException extends PlatformTaskDefinitionIncompatibilityException_base {
 }
 declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
     readonly resourceIds: S.optional<S.$Array<S.String>>;
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        ConflictError: true;
+    };
+});
 export declare class ConflictException extends ConflictException_base {
 }
 declare const ServiceDeploymentNotFoundException_base: S.Class<ServiceDeploymentNotFoundException, S.TaggedStruct<"ServiceDeploymentNotFoundException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        NotFoundError: true;
+    };
+});
 export declare class ServiceDeploymentNotFoundException extends ServiceDeploymentNotFoundException_base {
 }
 declare const BlockedException_base: S.Class<BlockedException, S.TaggedStruct<"BlockedException", {
     readonly message: S.optional<S.String>;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
+    "@distilled.cloud/error/categories": {
+        BadRequestError: true;
+    };
+});
 export declare class BlockedException extends BlockedException_base {
 }
 export type DeleteAccountSettingError = AccessDeniedException | ClientException | InvalidParameterException | ServerException | CommonErrors;