@aws-sdk/client-deadline 3.977.0 → 3.980.0

package/dist-cjs/index.js

@@ -4859,125 +4859,6 @@ class UpdateWorkerScheduleCommand extends smithyClient.Command
     .build() {
 }
 
-const commands = {
-    AssociateMemberToFarmCommand,
-    AssociateMemberToFleetCommand,
-    AssociateMemberToJobCommand,
-    AssociateMemberToQueueCommand,
-    AssumeFleetRoleForReadCommand,
-    AssumeFleetRoleForWorkerCommand,
-    AssumeQueueRoleForReadCommand,
-    AssumeQueueRoleForUserCommand,
-    AssumeQueueRoleForWorkerCommand,
-    BatchGetJobEntityCommand,
-    CopyJobTemplateCommand,
-    CreateBudgetCommand,
-    CreateFarmCommand,
-    CreateFleetCommand,
-    CreateJobCommand,
-    CreateLicenseEndpointCommand,
-    CreateLimitCommand,
-    CreateMonitorCommand,
-    CreateQueueCommand,
-    CreateQueueEnvironmentCommand,
-    CreateQueueFleetAssociationCommand,
-    CreateQueueLimitAssociationCommand,
-    CreateStorageProfileCommand,
-    CreateWorkerCommand,
-    DeleteBudgetCommand,
-    DeleteFarmCommand,
-    DeleteFleetCommand,
-    DeleteLicenseEndpointCommand,
-    DeleteLimitCommand,
-    DeleteMeteredProductCommand,
-    DeleteMonitorCommand,
-    DeleteQueueCommand,
-    DeleteQueueEnvironmentCommand,
-    DeleteQueueFleetAssociationCommand,
-    DeleteQueueLimitAssociationCommand,
-    DeleteStorageProfileCommand,
-    DeleteWorkerCommand,
-    DisassociateMemberFromFarmCommand,
-    DisassociateMemberFromFleetCommand,
-    DisassociateMemberFromJobCommand,
-    DisassociateMemberFromQueueCommand,
-    GetBudgetCommand,
-    GetFarmCommand,
-    GetFleetCommand,
-    GetJobCommand,
-    GetLicenseEndpointCommand,
-    GetLimitCommand,
-    GetMonitorCommand,
-    GetQueueCommand,
-    GetQueueEnvironmentCommand,
-    GetQueueFleetAssociationCommand,
-    GetQueueLimitAssociationCommand,
-    GetSessionCommand,
-    GetSessionActionCommand,
-    GetSessionsStatisticsAggregationCommand,
-    GetStepCommand,
-    GetStorageProfileCommand,
-    GetStorageProfileForQueueCommand,
-    GetTaskCommand,
-    GetWorkerCommand,
-    ListAvailableMeteredProductsCommand,
-    ListBudgetsCommand,
-    ListFarmMembersCommand,
-    ListFarmsCommand,
-    ListFleetMembersCommand,
-    ListFleetsCommand,
-    ListJobMembersCommand,
-    ListJobParameterDefinitionsCommand,
-    ListJobsCommand,
-    ListLicenseEndpointsCommand,
-    ListLimitsCommand,
-    ListMeteredProductsCommand,
-    ListMonitorsCommand,
-    ListQueueEnvironmentsCommand,
-    ListQueueFleetAssociationsCommand,
-    ListQueueLimitAssociationsCommand,
-    ListQueueMembersCommand,
-    ListQueuesCommand,
-    ListSessionActionsCommand,
-    ListSessionsCommand,
-    ListSessionsForWorkerCommand,
-    ListStepConsumersCommand,
-    ListStepDependenciesCommand,
-    ListStepsCommand,
-    ListStorageProfilesCommand,
-    ListStorageProfilesForQueueCommand,
-    ListTagsForResourceCommand,
-    ListTasksCommand,
-    ListWorkersCommand,
-    PutMeteredProductCommand,
-    SearchJobsCommand,
-    SearchStepsCommand,
-    SearchTasksCommand,
-    SearchWorkersCommand,
-    StartSessionsStatisticsAggregationCommand,
-    TagResourceCommand,
-    UntagResourceCommand,
-    UpdateBudgetCommand,
-    UpdateFarmCommand,
-    UpdateFleetCommand,
-    UpdateJobCommand,
-    UpdateLimitCommand,
-    UpdateMonitorCommand,
-    UpdateQueueCommand,
-    UpdateQueueEnvironmentCommand,
-    UpdateQueueFleetAssociationCommand,
-    UpdateQueueLimitAssociationCommand,
-    UpdateSessionCommand,
-    UpdateStepCommand,
-    UpdateStorageProfileCommand,
-    UpdateTaskCommand,
-    UpdateWorkerCommand,
-    UpdateWorkerScheduleCommand,
-};
-class Deadline extends DeadlineClient {
-}
-smithyClient.createAggregatedClient(commands, Deadline);
-
 const paginateGetSessionsStatisticsAggregation = core.createPaginator(DeadlineClient, GetSessionsStatisticsAggregationCommand, "nextToken", "nextToken", "maxResults");
 
 const paginateListAvailableMeteredProducts = core.createPaginator(DeadlineClient, ListAvailableMeteredProductsCommand, "nextToken", "nextToken", "maxResults");
@@ -5018,20 +4899,20 @@ const paginateListQueues = core.createPaginator(DeadlineClient, ListQueuesComman
 
 const paginateListSessionActions = core.createPaginator(DeadlineClient, ListSessionActionsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListSessions = core.createPaginator(DeadlineClient, ListSessionsCommand, "nextToken", "nextToken", "maxResults");
-
 const paginateListSessionsForWorker = core.createPaginator(DeadlineClient, ListSessionsForWorkerCommand, "nextToken", "nextToken", "maxResults");
 
+const paginateListSessions = core.createPaginator(DeadlineClient, ListSessionsCommand, "nextToken", "nextToken", "maxResults");
+
 const paginateListStepConsumers = core.createPaginator(DeadlineClient, ListStepConsumersCommand, "nextToken", "nextToken", "maxResults");
 
 const paginateListStepDependencies = core.createPaginator(DeadlineClient, ListStepDependenciesCommand, "nextToken", "nextToken", "maxResults");
 
 const paginateListSteps = core.createPaginator(DeadlineClient, ListStepsCommand, "nextToken", "nextToken", "maxResults");
 
-const paginateListStorageProfiles = core.createPaginator(DeadlineClient, ListStorageProfilesCommand, "nextToken", "nextToken", "maxResults");
-
 const paginateListStorageProfilesForQueue = core.createPaginator(DeadlineClient, ListStorageProfilesForQueueCommand, "nextToken", "nextToken", "maxResults");
 
+const paginateListStorageProfiles = core.createPaginator(DeadlineClient, ListStorageProfilesCommand, "nextToken", "nextToken", "maxResults");
+
 const paginateListTasks = core.createPaginator(DeadlineClient, ListTasksCommand, "nextToken", "nextToken", "maxResults");
 
 const paginateListWorkers = core.createPaginator(DeadlineClient, ListWorkersCommand, "nextToken", "nextToken", "maxResults");
@@ -5091,46 +4972,46 @@ const checkState$8 = async (client, input) => {
         reason = result;
         try {
             const returnComparator = () => {
-                return result.lifecycleStatus;
+                return result.taskRunStatus;
             };
-            if (returnComparator() === "CREATE_COMPLETE") {
+            if (returnComparator() === "SUCCEEDED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
         try {
             const returnComparator = () => {
-                return result.lifecycleStatus;
+                return result.taskRunStatus;
             };
-            if (returnComparator() === "UPDATE_IN_PROGRESS") {
+            if (returnComparator() === "FAILED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
         try {
             const returnComparator = () => {
-                return result.lifecycleStatus;
+                return result.taskRunStatus;
             };
-            if (returnComparator() === "UPDATE_FAILED") {
+            if (returnComparator() === "CANCELED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
         try {
             const returnComparator = () => {
-                return result.lifecycleStatus;
+                return result.taskRunStatus;
             };
-            if (returnComparator() === "UPDATE_SUCCEEDED") {
+            if (returnComparator() === "SUSPENDED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
         try {
             const returnComparator = () => {
-                return result.lifecycleStatus;
+                return result.taskRunStatus;
             };
-            if (returnComparator() === "UPLOAD_FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            if (returnComparator() === "NOT_COMPATIBLE") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -5138,8 +5019,8 @@ const checkState$8 = async (client, input) => {
             const returnComparator = () => {
                 return result.lifecycleStatus;
             };
-            if (returnComparator() === "CREATE_FAILED") {
-                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            if (returnComparator() === "ARCHIVED") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
@@ -5149,12 +5030,12 @@ const checkState$8 = async (client, input) => {
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForJobCreateComplete = async (params, input) => {
-    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+const waitForJobComplete = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 3600 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
 };
-const waitUntilJobCreateComplete = async (params, input) => {
-    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
+const waitUntilJobComplete = async (params, input) => {
+    const serviceDefaults = { minDelay: 15, maxDelay: 3600 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$8);
     return utilWaiter.checkExceptions(result);
 };
@@ -5166,46 +5047,46 @@ const checkState$7 = async (client, input) => {
         reason = result;
         try {
             const returnComparator = () => {
-                return result.taskRunStatus;
+                return result.lifecycleStatus;
             };
-            if (returnComparator() === "SUCCEEDED") {
+            if (returnComparator() === "CREATE_COMPLETE") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
         try {
             const returnComparator = () => {
-                return result.taskRunStatus;
+                return result.lifecycleStatus;
             };
-            if (returnComparator() === "FAILED") {
+            if (returnComparator() === "UPDATE_IN_PROGRESS") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
         try {
             const returnComparator = () => {
-                return result.taskRunStatus;
+                return result.lifecycleStatus;
             };
-            if (returnComparator() === "CANCELED") {
+            if (returnComparator() === "UPDATE_FAILED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
         try {
             const returnComparator = () => {
-                return result.taskRunStatus;
+                return result.lifecycleStatus;
             };
-            if (returnComparator() === "SUSPENDED") {
+            if (returnComparator() === "UPDATE_SUCCEEDED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
         catch (e) { }
         try {
             const returnComparator = () => {
-                return result.taskRunStatus;
+                return result.lifecycleStatus;
             };
-            if (returnComparator() === "NOT_COMPATIBLE") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            if (returnComparator() === "UPLOAD_FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -5213,8 +5094,8 @@ const checkState$7 = async (client, input) => {
             const returnComparator = () => {
                 return result.lifecycleStatus;
             };
-            if (returnComparator() === "ARCHIVED") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            if (returnComparator() === "CREATE_FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
             }
         }
         catch (e) { }
@@ -5224,12 +5105,12 @@ const checkState$7 = async (client, input) => {
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForJobComplete = async (params, input) => {
-    const serviceDefaults = { minDelay: 15, maxDelay: 3600 };
+const waitForJobCreateComplete = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
 };
-const waitUntilJobComplete = async (params, input) => {
-    const serviceDefaults = { minDelay: 15, maxDelay: 3600 };
+const waitUntilJobCreateComplete = async (params, input) => {
+    const serviceDefaults = { minDelay: 1, maxDelay: 120 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$7);
     return utilWaiter.checkExceptions(result);
 };
@@ -5314,15 +5195,6 @@ const checkState$5 = async (client, input) => {
     try {
         let result = await client.send(new GetLicenseEndpointCommand(input));
         reason = result;
-        try {
-            const returnComparator = () => {
-                return result.status;
-            };
-            if (returnComparator() === "READY") {
-                return { state: utilWaiter.WaiterState.SUCCESS, reason };
-            }
-        }
-        catch (e) { }
         try {
             const returnComparator = () => {
                 return result.status;
@@ -5335,15 +5207,18 @@ const checkState$5 = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: utilWaiter.WaiterState.SUCCESS, reason };
+        }
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForLicenseEndpointValid = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 1140 };
+const waitForLicenseEndpointDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 2340 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
 };
-const waitUntilLicenseEndpointValid = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 1140 };
+const waitUntilLicenseEndpointDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 2340 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$5);
     return utilWaiter.checkExceptions(result);
 };
@@ -5353,6 +5228,15 @@ const checkState$4 = async (client, input) => {
     try {
         let result = await client.send(new GetLicenseEndpointCommand(input));
         reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "READY") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
         try {
             const returnComparator = () => {
                 return result.status;
@@ -5365,18 +5249,15 @@ const checkState$4 = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
-        if (exception.name && exception.name == "ResourceNotFoundException") {
-            return { state: utilWaiter.WaiterState.SUCCESS, reason };
-        }
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForLicenseEndpointDeleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 2340 };
+const waitForLicenseEndpointValid = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1140 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
 };
-const waitUntilLicenseEndpointDeleted = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 2340 };
+const waitUntilLicenseEndpointValid = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 1140 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$4);
     return utilWaiter.checkExceptions(result);
 };
@@ -5384,13 +5265,13 @@ const waitUntilLicenseEndpointDeleted = async (params, input) => {
 const checkState$3 = async (client, input) => {
     let reason;
     try {
-        let result = await client.send(new GetQueueCommand(input));
+        let result = await client.send(new GetQueueFleetAssociationCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
-            if (returnComparator() === "SCHEDULING_BLOCKED") {
+            if (returnComparator() === "STOPPED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
@@ -5401,12 +5282,12 @@ const checkState$3 = async (client, input) => {
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForQueueSchedulingBlocked = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 300 };
+const waitForQueueFleetAssociationStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 600 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
-const waitUntilQueueSchedulingBlocked = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 300 };
+const waitUntilQueueFleetAssociationStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 600 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
     return utilWaiter.checkExceptions(result);
 };
@@ -5414,13 +5295,13 @@ const waitUntilQueueSchedulingBlocked = async (params, input) => {
 const checkState$2 = async (client, input) => {
     let reason;
     try {
-        let result = await client.send(new GetQueueCommand(input));
+        let result = await client.send(new GetQueueLimitAssociationCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
-            if (returnComparator() === "SCHEDULING") {
+            if (returnComparator() === "STOPPED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
@@ -5431,12 +5312,12 @@ const checkState$2 = async (client, input) => {
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForQueueScheduling = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 700 };
+const waitForQueueLimitAssociationStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 600 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
-const waitUntilQueueScheduling = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 700 };
+const waitUntilQueueLimitAssociationStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 600 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
     return utilWaiter.checkExceptions(result);
 };
@@ -5444,13 +5325,13 @@ const waitUntilQueueScheduling = async (params, input) => {
 const checkState$1 = async (client, input) => {
     let reason;
     try {
-        let result = await client.send(new GetQueueFleetAssociationCommand(input));
+        let result = await client.send(new GetQueueCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
-            if (returnComparator() === "STOPPED") {
+            if (returnComparator() === "SCHEDULING") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
@@ -5461,12 +5342,12 @@ const checkState$1 = async (client, input) => {
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForQueueFleetAssociationStopped = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 600 };
+const waitForQueueScheduling = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 700 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
-const waitUntilQueueFleetAssociationStopped = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 600 };
+const waitUntilQueueScheduling = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 700 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
     return utilWaiter.checkExceptions(result);
 };
@@ -5474,13 +5355,13 @@ const waitUntilQueueFleetAssociationStopped = async (params, input) => {
 const checkState = async (client, input) => {
     let reason;
     try {
-        let result = await client.send(new GetQueueLimitAssociationCommand(input));
+        let result = await client.send(new GetQueueCommand(input));
         reason = result;
         try {
             const returnComparator = () => {
                 return result.status;
             };
-            if (returnComparator() === "STOPPED") {
+            if (returnComparator() === "SCHEDULING_BLOCKED") {
                 return { state: utilWaiter.WaiterState.SUCCESS, reason };
             }
         }
@@ -5491,16 +5372,178 @@ const checkState = async (client, input) => {
     }
     return { state: utilWaiter.WaiterState.RETRY, reason };
 };
-const waitForQueueLimitAssociationStopped = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 600 };
+const waitForQueueSchedulingBlocked = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 300 };
     return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
 };
-const waitUntilQueueLimitAssociationStopped = async (params, input) => {
-    const serviceDefaults = { minDelay: 10, maxDelay: 600 };
+const waitUntilQueueSchedulingBlocked = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 300 };
     const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
     return utilWaiter.checkExceptions(result);
 };
 
+const commands = {
+    AssociateMemberToFarmCommand,
+    AssociateMemberToFleetCommand,
+    AssociateMemberToJobCommand,
+    AssociateMemberToQueueCommand,
+    AssumeFleetRoleForReadCommand,
+    AssumeFleetRoleForWorkerCommand,
+    AssumeQueueRoleForReadCommand,
+    AssumeQueueRoleForUserCommand,
+    AssumeQueueRoleForWorkerCommand,
+    BatchGetJobEntityCommand,
+    CopyJobTemplateCommand,
+    CreateBudgetCommand,
+    CreateFarmCommand,
+    CreateFleetCommand,
+    CreateJobCommand,
+    CreateLicenseEndpointCommand,
+    CreateLimitCommand,
+    CreateMonitorCommand,
+    CreateQueueCommand,
+    CreateQueueEnvironmentCommand,
+    CreateQueueFleetAssociationCommand,
+    CreateQueueLimitAssociationCommand,
+    CreateStorageProfileCommand,
+    CreateWorkerCommand,
+    DeleteBudgetCommand,
+    DeleteFarmCommand,
+    DeleteFleetCommand,
+    DeleteLicenseEndpointCommand,
+    DeleteLimitCommand,
+    DeleteMeteredProductCommand,
+    DeleteMonitorCommand,
+    DeleteQueueCommand,
+    DeleteQueueEnvironmentCommand,
+    DeleteQueueFleetAssociationCommand,
+    DeleteQueueLimitAssociationCommand,
+    DeleteStorageProfileCommand,
+    DeleteWorkerCommand,
+    DisassociateMemberFromFarmCommand,
+    DisassociateMemberFromFleetCommand,
+    DisassociateMemberFromJobCommand,
+    DisassociateMemberFromQueueCommand,
+    GetBudgetCommand,
+    GetFarmCommand,
+    GetFleetCommand,
+    GetJobCommand,
+    GetLicenseEndpointCommand,
+    GetLimitCommand,
+    GetMonitorCommand,
+    GetQueueCommand,
+    GetQueueEnvironmentCommand,
+    GetQueueFleetAssociationCommand,
+    GetQueueLimitAssociationCommand,
+    GetSessionCommand,
+    GetSessionActionCommand,
+    GetSessionsStatisticsAggregationCommand,
+    GetStepCommand,
+    GetStorageProfileCommand,
+    GetStorageProfileForQueueCommand,
+    GetTaskCommand,
+    GetWorkerCommand,
+    ListAvailableMeteredProductsCommand,
+    ListBudgetsCommand,
+    ListFarmMembersCommand,
+    ListFarmsCommand,
+    ListFleetMembersCommand,
+    ListFleetsCommand,
+    ListJobMembersCommand,
+    ListJobParameterDefinitionsCommand,
+    ListJobsCommand,
+    ListLicenseEndpointsCommand,
+    ListLimitsCommand,
+    ListMeteredProductsCommand,
+    ListMonitorsCommand,
+    ListQueueEnvironmentsCommand,
+    ListQueueFleetAssociationsCommand,
+    ListQueueLimitAssociationsCommand,
+    ListQueueMembersCommand,
+    ListQueuesCommand,
+    ListSessionActionsCommand,
+    ListSessionsCommand,
+    ListSessionsForWorkerCommand,
+    ListStepConsumersCommand,
+    ListStepDependenciesCommand,
+    ListStepsCommand,
+    ListStorageProfilesCommand,
+    ListStorageProfilesForQueueCommand,
+    ListTagsForResourceCommand,
+    ListTasksCommand,
+    ListWorkersCommand,
+    PutMeteredProductCommand,
+    SearchJobsCommand,
+    SearchStepsCommand,
+    SearchTasksCommand,
+    SearchWorkersCommand,
+    StartSessionsStatisticsAggregationCommand,
+    TagResourceCommand,
+    UntagResourceCommand,
+    UpdateBudgetCommand,
+    UpdateFarmCommand,
+    UpdateFleetCommand,
+    UpdateJobCommand,
+    UpdateLimitCommand,
+    UpdateMonitorCommand,
+    UpdateQueueCommand,
+    UpdateQueueEnvironmentCommand,
+    UpdateQueueFleetAssociationCommand,
+    UpdateQueueLimitAssociationCommand,
+    UpdateSessionCommand,
+    UpdateStepCommand,
+    UpdateStorageProfileCommand,
+    UpdateTaskCommand,
+    UpdateWorkerCommand,
+    UpdateWorkerScheduleCommand,
+};
+const paginators = {
+    paginateGetSessionsStatisticsAggregation,
+    paginateListAvailableMeteredProducts,
+    paginateListBudgets,
+    paginateListFarmMembers,
+    paginateListFarms,
+    paginateListFleetMembers,
+    paginateListFleets,
+    paginateListJobMembers,
+    paginateListJobParameterDefinitions,
+    paginateListJobs,
+    paginateListLicenseEndpoints,
+    paginateListLimits,
+    paginateListMeteredProducts,
+    paginateListMonitors,
+    paginateListQueueEnvironments,
+    paginateListQueueFleetAssociations,
+    paginateListQueueLimitAssociations,
+    paginateListQueueMembers,
+    paginateListQueues,
+    paginateListSessionActions,
+    paginateListSessions,
+    paginateListSessionsForWorker,
+    paginateListStepConsumers,
+    paginateListStepDependencies,
+    paginateListSteps,
+    paginateListStorageProfiles,
+    paginateListStorageProfilesForQueue,
+    paginateListTasks,
+    paginateListWorkers,
+};
+const waiters = {
+    waitUntilFleetActive,
+    waitUntilJobCreateComplete,
+    waitUntilJobComplete,
+    waitUntilJobSucceeded,
+    waitUntilLicenseEndpointValid,
+    waitUntilLicenseEndpointDeleted,
+    waitUntilQueueSchedulingBlocked,
+    waitUntilQueueScheduling,
+    waitUntilQueueFleetAssociationStopped,
+    waitUntilQueueLimitAssociationStopped,
+};
+class Deadline extends DeadlineClient {
+}
+smithyClient.createAggregatedClient(commands, Deadline, { paginators, waiters });
+
 const AcceleratorName = {
     A10G: "a10g",
     L4: "l4",