@aws-sdk/client-deadline 3.975.0 → 3.978.0

package/dist-cjs/index.js

@@ -513,6 +513,7 @@ const _JD = "JobDescription";
 const _JDE = "JobDetailsEntity";
 const _JDEo = "JobDetailsError";
 const _JDI = "JobDetailsIdentifiers";
+const _JDO = "JobDescriptionOverride";
 const _JE = "JobEntity";
 const _JEI = "JobEntityIdentifiers";
 const _JEIU = "JobEntityIdentifiersUnion";
@@ -862,6 +863,7 @@ const _dBA = "defaultBudgetAction";
 const _dC = "dependencyCounts";
 const _dN = "displayName";
 const _dNn = "dnsName";
+const _dO = "descriptionOverride";
 const _dP = "destinationPath";
 const _dR = "dependenciesResolved";
 const _dT = "dateTime";
@@ -973,6 +975,7 @@ const _mo = "mode";
 const _mon = "monitors";
 const _n = "name";
 const _nIO = "nextItemOffset";
+const _nO = "nameOverride";
 const _nT = "nextToken";
 const _o = "operator";
 const _oF = "osFamily";
@@ -1124,6 +1127,7 @@ var Document = [0, n0, _Do, 8, 15];
 var EnvironmentTemplate = [0, n0, _ET, 8, 0];
 var HostConfigurationScript = [0, n0, _HCS, 8, 0];
 var JobDescription = [0, n0, _JD, 8, 0];
+var JobDescriptionOverride = [0, n0, _JDO, 8, 0];
 var JobTemplate = [0, n0, _JT, 8, 0];
 var SecretAccessKey = [0, n0, _SAK, 8, 0];
 var SessionActionProgressMessage = [0, n0, _SAPM, 8, 0];
@@ -1368,8 +1372,8 @@ var CreateFleetResponse$ = [3, n0, _CFRrea,
 ];
 var CreateJobRequest$ = [3, n0, _CJR,
     0,
-    [_fI, _qI, _pr, _cT, _te, _tT, _p, _at, _sPI, _tTRS, _mFTC, _mRPT, _mWC, _sJI],
-    [[0, 1], [0, 1], 1, [0, { [_hH]: _XACT, [_iT]: 1 }], [() => JobTemplate, 0], 0, [() => JobParameters, 0], [() => Attachments$, 0], 0, 0, 1, 1, 1, 0], 3
+    [_fI, _qI, _pr, _cT, _te, _tT, _p, _at, _sPI, _tTRS, _mFTC, _mRPT, _mWC, _sJI, _nO, _dO],
+    [[0, 1], [0, 1], 1, [0, { [_hH]: _XACT, [_iT]: 1 }], [() => JobTemplate, 0], 0, [() => JobParameters, 0], [() => Attachments$, 0], 0, 0, 1, 1, 1, 0, 0, [() => JobDescriptionOverride, 0]], 3
 ];
 var CreateJobResponse$ = [3, n0, _CJRr,
     0,
@@ -2697,8 +2701,8 @@ var UpdateFleetResponse$ = [3, n0, _UFRpda,
 ];
 var UpdateJobRequest$ = [3, n0, _UJR,
     0,
-    [_fI, _qI, _jI, _cT, _tTRS, _pr, _mFTC, _mRPT, _lS, _mWC],
-    [[0, 1], [0, 1], [0, 1], [0, { [_hH]: _XACT, [_iT]: 1 }], 0, 1, 1, 1, 0, 1], 3
+    [_fI, _qI, _jI, _cT, _tTRS, _pr, _mFTC, _mRPT, _lS, _mWC, _n, _de],
+    [[0, 1], [0, 1], [0, 1], [0, { [_hH]: _XACT, [_iT]: 1 }], 0, 1, 1, 1, 0, 1, 0, [() => JobDescriptionOverride, 0]], 3
 ];
 var UpdateJobResponse$ = [3, n0, _UJRp,
     0,
@@ -4855,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");
@@ -5014,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");
@@ -5087,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) { }
@@ -5134,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) { }
@@ -5145,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);
 };
@@ -5162,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) { }
@@ -5209,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) { }
@@ -5220,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);
 };
@@ -5310,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;
@@ -5331,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);
 };
@@ -5349,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;
@@ -5361,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);
 };
@@ -5380,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 };
             }
         }
@@ -5397,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);
 };
@@ -5410,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 };
             }
         }
@@ -5427,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);
 };
@@ -5440,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 };
             }
         }
@@ -5457,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);
 };
@@ -5470,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 };
             }
         }
@@ -5487,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",