@aws-sdk/client-deadline 3.1036.0 → 3.1038.0

package/dist-cjs/index.js

@@ -1938,7 +1938,7 @@ const checkState$5 = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
-        if (exception.name && exception.name == "ResourceNotFoundException") {
+        if (exception.name === "ResourceNotFoundException") {
             return { state: utilWaiter.WaiterState.SUCCESS, reason };
         }
     }

package/dist-es/waiters/waitForLicenseEndpointDeleted.js

@@ -1,5 +1,5 @@
 import { checkExceptions, createWaiter, WaiterState, } from "@smithy/util-waiter";
-import { GetLicenseEndpointCommand } from "../commands/GetLicenseEndpointCommand";
+import { GetLicenseEndpointCommand, } from "../commands/GetLicenseEndpointCommand";
 const checkState = async (client, input) => {
     let reason;
     try {
@@ -17,7 +17,7 @@ const checkState = async (client, input) => {
     }
     catch (exception) {
         reason = exception;
-        if (exception.name && exception.name == "ResourceNotFoundException") {
+        if (exception.name === "ResourceNotFoundException") {
             return { state: WaiterState.SUCCESS, reason };
         }
     }

package/dist-es/waiters/waitForLicenseEndpointValid.js

@@ -1,5 +1,5 @@
 import { checkExceptions, createWaiter, WaiterState, } from "@smithy/util-waiter";
-import { GetLicenseEndpointCommand } from "../commands/GetLicenseEndpointCommand";
+import { GetLicenseEndpointCommand, } from "../commands/GetLicenseEndpointCommand";
 const checkState = async (client, input) => {
     let reason;
     try {

package/dist-types/Deadline.d.ts

@@ -124,6 +124,7 @@ import { type UpdateTaskCommandInput, type UpdateTaskCommandOutput } from "./com
 import { type UpdateWorkerCommandInput, type UpdateWorkerCommandOutput } from "./commands/UpdateWorkerCommand";
 import { type UpdateWorkerScheduleCommandInput, type UpdateWorkerScheduleCommandOutput } from "./commands/UpdateWorkerScheduleCommand";
 import { DeadlineClient } from "./DeadlineClient";
+import type { ResourceNotFoundException } from "./models/errors";
 export interface Deadline {
     /**
      * @see {@link AssociateMemberToFarmCommand}
@@ -1075,61 +1076,61 @@ export interface Deadline {
      * @param args - command input.
      * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
      */
-    waitUntilFleetActive(args: GetFleetCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult>;
+    waitUntilFleetActive(args: GetFleetCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult<GetFleetCommandOutput>>;
     /**
      * @see {@link GetJobCommand}
      * @param args - command input.
      * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
      */
-    waitUntilJobCreateComplete(args: GetJobCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult>;
+    waitUntilJobCreateComplete(args: GetJobCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult<GetJobCommandOutput>>;
     /**
      * @see {@link GetJobCommand}
      * @param args - command input.
      * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
      */
-    waitUntilJobComplete(args: GetJobCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult>;
+    waitUntilJobComplete(args: GetJobCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult<GetJobCommandOutput>>;
     /**
      * @see {@link GetJobCommand}
      * @param args - command input.
      * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
      */
-    waitUntilJobSucceeded(args: GetJobCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult>;
+    waitUntilJobSucceeded(args: GetJobCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult<GetJobCommandOutput>>;
     /**
      * @see {@link GetLicenseEndpointCommand}
      * @param args - command input.
      * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
      */
-    waitUntilLicenseEndpointValid(args: GetLicenseEndpointCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult>;
+    waitUntilLicenseEndpointValid(args: GetLicenseEndpointCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult<GetLicenseEndpointCommandOutput>>;
     /**
      * @see {@link GetLicenseEndpointCommand}
      * @param args - command input.
      * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
      */
-    waitUntilLicenseEndpointDeleted(args: GetLicenseEndpointCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult>;
+    waitUntilLicenseEndpointDeleted(args: GetLicenseEndpointCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult<ResourceNotFoundException>>;
     /**
      * @see {@link GetQueueCommand}
      * @param args - command input.
      * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
      */
-    waitUntilQueueSchedulingBlocked(args: GetQueueCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult>;
+    waitUntilQueueSchedulingBlocked(args: GetQueueCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult<GetQueueCommandOutput>>;
     /**
      * @see {@link GetQueueCommand}
      * @param args - command input.
      * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
      */
-    waitUntilQueueScheduling(args: GetQueueCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult>;
+    waitUntilQueueScheduling(args: GetQueueCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult<GetQueueCommandOutput>>;
     /**
      * @see {@link GetQueueFleetAssociationCommand}
      * @param args - command input.
      * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
      */
-    waitUntilQueueFleetAssociationStopped(args: GetQueueFleetAssociationCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult>;
+    waitUntilQueueFleetAssociationStopped(args: GetQueueFleetAssociationCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult<GetQueueFleetAssociationCommandOutput>>;
     /**
      * @see {@link GetQueueLimitAssociationCommand}
      * @param args - command input.
      * @param waiterConfig - `maxWaitTime` in seconds or waiter config object.
      */
-    waitUntilQueueLimitAssociationStopped(args: GetQueueLimitAssociationCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult>;
+    waitUntilQueueLimitAssociationStopped(args: GetQueueLimitAssociationCommandInput, waiterConfig: number | Omit<WaiterConfiguration<Deadline>, "client">): Promise<WaiterResult<GetQueueLimitAssociationCommandOutput>>;
 }
 /**
  * <p>The Amazon Web Services Deadline Cloud API provides infrastructure and centralized management for your projects. Use the Deadline Cloud API to onboard users, assign projects, and attach permissions specific to their job function.</p> <p>With Deadline Cloud, content production teams can deploy resources for their workforce securely in the cloud, reducing the costs of added physical infrastructure. Keep your content production operations secure, while allowing your contributors to access the tools they need, such as scalable high-speed storage, licenses, and cost management services.</p>

package/dist-types/ts3.4/Deadline.d.ts

@@ -498,6 +498,7 @@ import {
   UpdateWorkerScheduleCommandOutput,
 } from "./commands/UpdateWorkerScheduleCommand";
 import { DeadlineClient } from "./DeadlineClient";
+import { ResourceNotFoundException } from "./models/errors";
 export interface Deadline {
   associateMemberToFarm(
     args: AssociateMemberToFarmCommandInput,
@@ -2319,7 +2320,7 @@ export interface Deadline {
           WaiterConfiguration<Deadline>,
           Exclude<keyof WaiterConfiguration<Deadline>, "client">
         >
-  ): Promise<WaiterResult>;
+  ): Promise<WaiterResult<GetFleetCommandOutput>>;
   waitUntilJobCreateComplete(
     args: GetJobCommandInput,
     waiterConfig:
@@ -2328,7 +2329,7 @@ export interface Deadline {
           WaiterConfiguration<Deadline>,
           Exclude<keyof WaiterConfiguration<Deadline>, "client">
         >
-  ): Promise<WaiterResult>;
+  ): Promise<WaiterResult<GetJobCommandOutput>>;
   waitUntilJobComplete(
     args: GetJobCommandInput,
     waiterConfig:
@@ -2337,7 +2338,7 @@ export interface Deadline {
           WaiterConfiguration<Deadline>,
           Exclude<keyof WaiterConfiguration<Deadline>, "client">
         >
-  ): Promise<WaiterResult>;
+  ): Promise<WaiterResult<GetJobCommandOutput>>;
   waitUntilJobSucceeded(
     args: GetJobCommandInput,
     waiterConfig:
@@ -2346,7 +2347,7 @@ export interface Deadline {
           WaiterConfiguration<Deadline>,
           Exclude<keyof WaiterConfiguration<Deadline>, "client">
         >
-  ): Promise<WaiterResult>;
+  ): Promise<WaiterResult<GetJobCommandOutput>>;
   waitUntilLicenseEndpointValid(
     args: GetLicenseEndpointCommandInput,
     waiterConfig:
@@ -2355,7 +2356,7 @@ export interface Deadline {
           WaiterConfiguration<Deadline>,
           Exclude<keyof WaiterConfiguration<Deadline>, "client">
         >
-  ): Promise<WaiterResult>;
+  ): Promise<WaiterResult<GetLicenseEndpointCommandOutput>>;
   waitUntilLicenseEndpointDeleted(
     args: GetLicenseEndpointCommandInput,
     waiterConfig:
@@ -2364,7 +2365,7 @@ export interface Deadline {
           WaiterConfiguration<Deadline>,
           Exclude<keyof WaiterConfiguration<Deadline>, "client">
         >
-  ): Promise<WaiterResult>;
+  ): Promise<WaiterResult<ResourceNotFoundException>>;
   waitUntilQueueSchedulingBlocked(
     args: GetQueueCommandInput,
     waiterConfig:
@@ -2373,7 +2374,7 @@ export interface Deadline {
           WaiterConfiguration<Deadline>,
           Exclude<keyof WaiterConfiguration<Deadline>, "client">
         >
-  ): Promise<WaiterResult>;
+  ): Promise<WaiterResult<GetQueueCommandOutput>>;
   waitUntilQueueScheduling(
     args: GetQueueCommandInput,
     waiterConfig:
@@ -2382,7 +2383,7 @@ export interface Deadline {
           WaiterConfiguration<Deadline>,
           Exclude<keyof WaiterConfiguration<Deadline>, "client">
         >
-  ): Promise<WaiterResult>;
+  ): Promise<WaiterResult<GetQueueCommandOutput>>;
   waitUntilQueueFleetAssociationStopped(
     args: GetQueueFleetAssociationCommandInput,
     waiterConfig:
@@ -2391,7 +2392,7 @@ export interface Deadline {
           WaiterConfiguration<Deadline>,
           Exclude<keyof WaiterConfiguration<Deadline>, "client">
         >
-  ): Promise<WaiterResult>;
+  ): Promise<WaiterResult<GetQueueFleetAssociationCommandOutput>>;
   waitUntilQueueLimitAssociationStopped(
     args: GetQueueLimitAssociationCommandInput,
     waiterConfig:
@@ -2400,6 +2401,6 @@ export interface Deadline {
           WaiterConfiguration<Deadline>,
           Exclude<keyof WaiterConfiguration<Deadline>, "client">
         >
-  ): Promise<WaiterResult>;
+  ): Promise<WaiterResult<GetQueueLimitAssociationCommandOutput>>;
 }
 export declare class Deadline extends DeadlineClient implements Deadline {}

package/dist-types/ts3.4/waiters/waitForFleetActive.d.ts

@@ -1,11 +1,15 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { GetFleetCommandInput } from "../commands/GetFleetCommand";
+import {
+  GetFleetCommandInput,
+  GetFleetCommandOutput,
+} from "../commands/GetFleetCommand";
 import { DeadlineClient } from "../DeadlineClient";
+import { DeadlineServiceException } from "../models/DeadlineServiceException";
 export declare const waitForFleetActive: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetFleetCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetFleetCommandOutput | DeadlineServiceException>>;
 export declare const waitUntilFleetActive: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetFleetCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetFleetCommandOutput>>;

package/dist-types/ts3.4/waiters/waitForJobComplete.d.ts

@@ -1,11 +1,15 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { GetJobCommandInput } from "../commands/GetJobCommand";
+import {
+  GetJobCommandInput,
+  GetJobCommandOutput,
+} from "../commands/GetJobCommand";
 import { DeadlineClient } from "../DeadlineClient";
+import { DeadlineServiceException } from "../models/DeadlineServiceException";
 export declare const waitForJobComplete: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetJobCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetJobCommandOutput | DeadlineServiceException>>;
 export declare const waitUntilJobComplete: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetJobCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetJobCommandOutput>>;

package/dist-types/ts3.4/waiters/waitForJobCreateComplete.d.ts

@@ -1,11 +1,15 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { GetJobCommandInput } from "../commands/GetJobCommand";
+import {
+  GetJobCommandInput,
+  GetJobCommandOutput,
+} from "../commands/GetJobCommand";
 import { DeadlineClient } from "../DeadlineClient";
+import { DeadlineServiceException } from "../models/DeadlineServiceException";
 export declare const waitForJobCreateComplete: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetJobCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetJobCommandOutput | DeadlineServiceException>>;
 export declare const waitUntilJobCreateComplete: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetJobCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetJobCommandOutput>>;

package/dist-types/ts3.4/waiters/waitForJobSucceeded.d.ts

@@ -1,11 +1,15 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { GetJobCommandInput } from "../commands/GetJobCommand";
+import {
+  GetJobCommandInput,
+  GetJobCommandOutput,
+} from "../commands/GetJobCommand";
 import { DeadlineClient } from "../DeadlineClient";
+import { DeadlineServiceException } from "../models/DeadlineServiceException";
 export declare const waitForJobSucceeded: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetJobCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetJobCommandOutput | DeadlineServiceException>>;
 export declare const waitUntilJobSucceeded: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetJobCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetJobCommandOutput>>;

package/dist-types/ts3.4/waiters/waitForLicenseEndpointDeleted.d.ts

@@ -1,11 +1,18 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { GetLicenseEndpointCommandInput } from "../commands/GetLicenseEndpointCommand";
+import {
+  GetLicenseEndpointCommandInput,
+  GetLicenseEndpointCommandOutput,
+} from "../commands/GetLicenseEndpointCommand";
 import { DeadlineClient } from "../DeadlineClient";
+import { DeadlineServiceException } from "../models/DeadlineServiceException";
+import { ResourceNotFoundException } from "../models/errors";
 export declare const waitForLicenseEndpointDeleted: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetLicenseEndpointCommandInput
-) => Promise<WaiterResult>;
+) => Promise<
+  WaiterResult<GetLicenseEndpointCommandOutput | DeadlineServiceException>
+>;
 export declare const waitUntilLicenseEndpointDeleted: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetLicenseEndpointCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<ResourceNotFoundException>>;

package/dist-types/ts3.4/waiters/waitForLicenseEndpointValid.d.ts

@@ -1,11 +1,17 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { GetLicenseEndpointCommandInput } from "../commands/GetLicenseEndpointCommand";
+import {
+  GetLicenseEndpointCommandInput,
+  GetLicenseEndpointCommandOutput,
+} from "../commands/GetLicenseEndpointCommand";
 import { DeadlineClient } from "../DeadlineClient";
+import { DeadlineServiceException } from "../models/DeadlineServiceException";
 export declare const waitForLicenseEndpointValid: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetLicenseEndpointCommandInput
-) => Promise<WaiterResult>;
+) => Promise<
+  WaiterResult<GetLicenseEndpointCommandOutput | DeadlineServiceException>
+>;
 export declare const waitUntilLicenseEndpointValid: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetLicenseEndpointCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetLicenseEndpointCommandOutput>>;

package/dist-types/ts3.4/waiters/waitForQueueFleetAssociationStopped.d.ts

@@ -1,11 +1,17 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { GetQueueFleetAssociationCommandInput } from "../commands/GetQueueFleetAssociationCommand";
+import {
+  GetQueueFleetAssociationCommandInput,
+  GetQueueFleetAssociationCommandOutput,
+} from "../commands/GetQueueFleetAssociationCommand";
 import { DeadlineClient } from "../DeadlineClient";
+import { DeadlineServiceException } from "../models/DeadlineServiceException";
 export declare const waitForQueueFleetAssociationStopped: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetQueueFleetAssociationCommandInput
-) => Promise<WaiterResult>;
+) => Promise<
+  WaiterResult<GetQueueFleetAssociationCommandOutput | DeadlineServiceException>
+>;
 export declare const waitUntilQueueFleetAssociationStopped: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetQueueFleetAssociationCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetQueueFleetAssociationCommandOutput>>;

package/dist-types/ts3.4/waiters/waitForQueueLimitAssociationStopped.d.ts

@@ -1,11 +1,17 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { GetQueueLimitAssociationCommandInput } from "../commands/GetQueueLimitAssociationCommand";
+import {
+  GetQueueLimitAssociationCommandInput,
+  GetQueueLimitAssociationCommandOutput,
+} from "../commands/GetQueueLimitAssociationCommand";
 import { DeadlineClient } from "../DeadlineClient";
+import { DeadlineServiceException } from "../models/DeadlineServiceException";
 export declare const waitForQueueLimitAssociationStopped: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetQueueLimitAssociationCommandInput
-) => Promise<WaiterResult>;
+) => Promise<
+  WaiterResult<GetQueueLimitAssociationCommandOutput | DeadlineServiceException>
+>;
 export declare const waitUntilQueueLimitAssociationStopped: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetQueueLimitAssociationCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetQueueLimitAssociationCommandOutput>>;

package/dist-types/ts3.4/waiters/waitForQueueScheduling.d.ts

@@ -1,11 +1,15 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { GetQueueCommandInput } from "../commands/GetQueueCommand";
+import {
+  GetQueueCommandInput,
+  GetQueueCommandOutput,
+} from "../commands/GetQueueCommand";
 import { DeadlineClient } from "../DeadlineClient";
+import { DeadlineServiceException } from "../models/DeadlineServiceException";
 export declare const waitForQueueScheduling: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetQueueCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetQueueCommandOutput | DeadlineServiceException>>;
 export declare const waitUntilQueueScheduling: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetQueueCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetQueueCommandOutput>>;

package/dist-types/ts3.4/waiters/waitForQueueSchedulingBlocked.d.ts

@@ -1,11 +1,15 @@
 import { WaiterConfiguration, WaiterResult } from "@smithy/util-waiter";
-import { GetQueueCommandInput } from "../commands/GetQueueCommand";
+import {
+  GetQueueCommandInput,
+  GetQueueCommandOutput,
+} from "../commands/GetQueueCommand";
 import { DeadlineClient } from "../DeadlineClient";
+import { DeadlineServiceException } from "../models/DeadlineServiceException";
 export declare const waitForQueueSchedulingBlocked: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetQueueCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetQueueCommandOutput | DeadlineServiceException>>;
 export declare const waitUntilQueueSchedulingBlocked: (
   params: WaiterConfiguration<DeadlineClient>,
   input: GetQueueCommandInput
-) => Promise<WaiterResult>;
+) => Promise<WaiterResult<GetQueueCommandOutput>>;

package/dist-types/waiters/waitForFleetActive.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type GetFleetCommandInput } from "../commands/GetFleetCommand";
+import { type GetFleetCommandInput, type GetFleetCommandOutput } from "../commands/GetFleetCommand";
 import type { DeadlineClient } from "../DeadlineClient";
+import type { DeadlineServiceException } from "../models/DeadlineServiceException";
 /**
  * Wait until a Fleet is activated. Use this after invoking CreateFleet or UpdateFleet.
  *  @deprecated Use waitUntilFleetActive instead. waitForFleetActive does not throw error in non-success cases.
  */
-export declare const waitForFleetActive: (params: WaiterConfiguration<DeadlineClient>, input: GetFleetCommandInput) => Promise<WaiterResult>;
+export declare const waitForFleetActive: (params: WaiterConfiguration<DeadlineClient>, input: GetFleetCommandInput) => Promise<WaiterResult<GetFleetCommandOutput | DeadlineServiceException>>;
 /**
  * Wait until a Fleet is activated. Use this after invoking CreateFleet or UpdateFleet.
  *  @param params - Waiter configuration options.
  *  @param input - The input to GetFleetCommand for polling.
  */
-export declare const waitUntilFleetActive: (params: WaiterConfiguration<DeadlineClient>, input: GetFleetCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilFleetActive: (params: WaiterConfiguration<DeadlineClient>, input: GetFleetCommandInput) => Promise<WaiterResult<GetFleetCommandOutput>>;

package/dist-types/waiters/waitForJobComplete.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type GetJobCommandInput } from "../commands/GetJobCommand";
+import { type GetJobCommandInput, type GetJobCommandOutput } from "../commands/GetJobCommand";
 import type { DeadlineClient } from "../DeadlineClient";
+import type { DeadlineServiceException } from "../models/DeadlineServiceException";
 /**
  * Wait until a job reaches any terminal status. Waits up to 1 hour by default.
  *  @deprecated Use waitUntilJobComplete instead. waitForJobComplete does not throw error in non-success cases.
  */
-export declare const waitForJobComplete: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult>;
+export declare const waitForJobComplete: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult<GetJobCommandOutput | DeadlineServiceException>>;
 /**
  * Wait until a job reaches any terminal status. Waits up to 1 hour by default.
  *  @param params - Waiter configuration options.
  *  @param input - The input to GetJobCommand for polling.
  */
-export declare const waitUntilJobComplete: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilJobComplete: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult<GetJobCommandOutput>>;

package/dist-types/waiters/waitForJobCreateComplete.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type GetJobCommandInput } from "../commands/GetJobCommand";
+import { type GetJobCommandInput, type GetJobCommandOutput } from "../commands/GetJobCommand";
 import type { DeadlineClient } from "../DeadlineClient";
+import type { DeadlineServiceException } from "../models/DeadlineServiceException";
 /**
  * Wait until a job is created. Use this after invoking CreateJob.
  *  @deprecated Use waitUntilJobCreateComplete instead. waitForJobCreateComplete does not throw error in non-success cases.
  */
-export declare const waitForJobCreateComplete: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult>;
+export declare const waitForJobCreateComplete: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult<GetJobCommandOutput | DeadlineServiceException>>;
 /**
  * Wait until a job is created. Use this after invoking CreateJob.
  *  @param params - Waiter configuration options.
  *  @param input - The input to GetJobCommand for polling.
  */
-export declare const waitUntilJobCreateComplete: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilJobCreateComplete: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult<GetJobCommandOutput>>;

package/dist-types/waiters/waitForJobSucceeded.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type GetJobCommandInput } from "../commands/GetJobCommand";
+import { type GetJobCommandInput, type GetJobCommandOutput } from "../commands/GetJobCommand";
 import type { DeadlineClient } from "../DeadlineClient";
+import type { DeadlineServiceException } from "../models/DeadlineServiceException";
 /**
  * Wait until a job has succeeded. Fails if the job reaches a non-successful terminal status. Waits up to 1 hour by default.
  *  @deprecated Use waitUntilJobSucceeded instead. waitForJobSucceeded does not throw error in non-success cases.
  */
-export declare const waitForJobSucceeded: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult>;
+export declare const waitForJobSucceeded: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult<GetJobCommandOutput | DeadlineServiceException>>;
 /**
  * Wait until a job has succeeded. Fails if the job reaches a non-successful terminal status. Waits up to 1 hour by default.
  *  @param params - Waiter configuration options.
  *  @param input - The input to GetJobCommand for polling.
  */
-export declare const waitUntilJobSucceeded: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilJobSucceeded: (params: WaiterConfiguration<DeadlineClient>, input: GetJobCommandInput) => Promise<WaiterResult<GetJobCommandOutput>>;

package/dist-types/waiters/waitForLicenseEndpointDeleted.d.ts

@@ -1,14 +1,16 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type GetLicenseEndpointCommandInput } from "../commands/GetLicenseEndpointCommand";
+import { type GetLicenseEndpointCommandInput, type GetLicenseEndpointCommandOutput } from "../commands/GetLicenseEndpointCommand";
 import type { DeadlineClient } from "../DeadlineClient";
+import type { DeadlineServiceException } from "../models/DeadlineServiceException";
+import type { ResourceNotFoundException } from "../models/errors";
 /**
  * Wait until a LicenseEndpoint is Deleted. Use this after invoking DeleteLicenseEndpoint.
  *  @deprecated Use waitUntilLicenseEndpointDeleted instead. waitForLicenseEndpointDeleted does not throw error in non-success cases.
  */
-export declare const waitForLicenseEndpointDeleted: (params: WaiterConfiguration<DeadlineClient>, input: GetLicenseEndpointCommandInput) => Promise<WaiterResult>;
+export declare const waitForLicenseEndpointDeleted: (params: WaiterConfiguration<DeadlineClient>, input: GetLicenseEndpointCommandInput) => Promise<WaiterResult<GetLicenseEndpointCommandOutput | DeadlineServiceException>>;
 /**
  * Wait until a LicenseEndpoint is Deleted. Use this after invoking DeleteLicenseEndpoint.
  *  @param params - Waiter configuration options.
  *  @param input - The input to GetLicenseEndpointCommand for polling.
  */
-export declare const waitUntilLicenseEndpointDeleted: (params: WaiterConfiguration<DeadlineClient>, input: GetLicenseEndpointCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilLicenseEndpointDeleted: (params: WaiterConfiguration<DeadlineClient>, input: GetLicenseEndpointCommandInput) => Promise<WaiterResult<ResourceNotFoundException>>;

package/dist-types/waiters/waitForLicenseEndpointValid.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type GetLicenseEndpointCommandInput } from "../commands/GetLicenseEndpointCommand";
+import { type GetLicenseEndpointCommandInput, type GetLicenseEndpointCommandOutput } from "../commands/GetLicenseEndpointCommand";
 import type { DeadlineClient } from "../DeadlineClient";
+import type { DeadlineServiceException } from "../models/DeadlineServiceException";
 /**
  * Wait until a LicenseEndpoint is Ready. Use this after invoking CreateLicenseEndpoint.
  *  @deprecated Use waitUntilLicenseEndpointValid instead. waitForLicenseEndpointValid does not throw error in non-success cases.
  */
-export declare const waitForLicenseEndpointValid: (params: WaiterConfiguration<DeadlineClient>, input: GetLicenseEndpointCommandInput) => Promise<WaiterResult>;
+export declare const waitForLicenseEndpointValid: (params: WaiterConfiguration<DeadlineClient>, input: GetLicenseEndpointCommandInput) => Promise<WaiterResult<GetLicenseEndpointCommandOutput | DeadlineServiceException>>;
 /**
  * Wait until a LicenseEndpoint is Ready. Use this after invoking CreateLicenseEndpoint.
  *  @param params - Waiter configuration options.
  *  @param input - The input to GetLicenseEndpointCommand for polling.
  */
-export declare const waitUntilLicenseEndpointValid: (params: WaiterConfiguration<DeadlineClient>, input: GetLicenseEndpointCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilLicenseEndpointValid: (params: WaiterConfiguration<DeadlineClient>, input: GetLicenseEndpointCommandInput) => Promise<WaiterResult<GetLicenseEndpointCommandOutput>>;

package/dist-types/waiters/waitForQueueFleetAssociationStopped.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type GetQueueFleetAssociationCommandInput } from "../commands/GetQueueFleetAssociationCommand";
+import { type GetQueueFleetAssociationCommandInput, type GetQueueFleetAssociationCommandOutput } from "../commands/GetQueueFleetAssociationCommand";
 import type { DeadlineClient } from "../DeadlineClient";
+import type { DeadlineServiceException } from "../models/DeadlineServiceException";
 /**
  * Wait until a QueueFleetAssociation is stopped. Use this after setting the status to STOP_SCHEDULING_AND_COMPLETE_TASKS or STOP_SCHEDULING_AND_CANCEL_TASKS to wait for a QueueFleetAssociation to reach STOPPED
  *  @deprecated Use waitUntilQueueFleetAssociationStopped instead. waitForQueueFleetAssociationStopped does not throw error in non-success cases.
  */
-export declare const waitForQueueFleetAssociationStopped: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueFleetAssociationCommandInput) => Promise<WaiterResult>;
+export declare const waitForQueueFleetAssociationStopped: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueFleetAssociationCommandInput) => Promise<WaiterResult<GetQueueFleetAssociationCommandOutput | DeadlineServiceException>>;
 /**
  * Wait until a QueueFleetAssociation is stopped. Use this after setting the status to STOP_SCHEDULING_AND_COMPLETE_TASKS or STOP_SCHEDULING_AND_CANCEL_TASKS to wait for a QueueFleetAssociation to reach STOPPED
  *  @param params - Waiter configuration options.
  *  @param input - The input to GetQueueFleetAssociationCommand for polling.
  */
-export declare const waitUntilQueueFleetAssociationStopped: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueFleetAssociationCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilQueueFleetAssociationStopped: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueFleetAssociationCommandInput) => Promise<WaiterResult<GetQueueFleetAssociationCommandOutput>>;

package/dist-types/waiters/waitForQueueLimitAssociationStopped.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type GetQueueLimitAssociationCommandInput } from "../commands/GetQueueLimitAssociationCommand";
+import { type GetQueueLimitAssociationCommandInput, type GetQueueLimitAssociationCommandOutput } from "../commands/GetQueueLimitAssociationCommand";
 import type { DeadlineClient } from "../DeadlineClient";
+import type { DeadlineServiceException } from "../models/DeadlineServiceException";
 /**
  * Wait until a QueueLimitAssociation is stopped. Use this after setting the status to STOP_LIMIT_USAGE_AND_COMPLETE_TASKS or STOP_LIMIT_USAGE_AND_CANCEL_TASKS to wait for a QueueLimitAssociation to reach STOPPED
  *  @deprecated Use waitUntilQueueLimitAssociationStopped instead. waitForQueueLimitAssociationStopped does not throw error in non-success cases.
  */
-export declare const waitForQueueLimitAssociationStopped: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueLimitAssociationCommandInput) => Promise<WaiterResult>;
+export declare const waitForQueueLimitAssociationStopped: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueLimitAssociationCommandInput) => Promise<WaiterResult<GetQueueLimitAssociationCommandOutput | DeadlineServiceException>>;
 /**
  * Wait until a QueueLimitAssociation is stopped. Use this after setting the status to STOP_LIMIT_USAGE_AND_COMPLETE_TASKS or STOP_LIMIT_USAGE_AND_CANCEL_TASKS to wait for a QueueLimitAssociation to reach STOPPED
  *  @param params - Waiter configuration options.
  *  @param input - The input to GetQueueLimitAssociationCommand for polling.
  */
-export declare const waitUntilQueueLimitAssociationStopped: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueLimitAssociationCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilQueueLimitAssociationStopped: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueLimitAssociationCommandInput) => Promise<WaiterResult<GetQueueLimitAssociationCommandOutput>>;

package/dist-types/waiters/waitForQueueScheduling.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type GetQueueCommandInput } from "../commands/GetQueueCommand";
+import { type GetQueueCommandInput, type GetQueueCommandOutput } from "../commands/GetQueueCommand";
 import type { DeadlineClient } from "../DeadlineClient";
+import type { DeadlineServiceException } from "../models/DeadlineServiceException";
 /**
  *
  *  @deprecated Use waitUntilQueueScheduling instead. waitForQueueScheduling does not throw error in non-success cases.
  */
-export declare const waitForQueueScheduling: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueCommandInput) => Promise<WaiterResult>;
+export declare const waitForQueueScheduling: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueCommandInput) => Promise<WaiterResult<GetQueueCommandOutput | DeadlineServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to GetQueueCommand for polling.
  */
-export declare const waitUntilQueueScheduling: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilQueueScheduling: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueCommandInput) => Promise<WaiterResult<GetQueueCommandOutput>>;

package/dist-types/waiters/waitForQueueSchedulingBlocked.d.ts

@@ -1,14 +1,15 @@
 import { type WaiterConfiguration, type WaiterResult } from "@smithy/util-waiter";
-import { type GetQueueCommandInput } from "../commands/GetQueueCommand";
+import { type GetQueueCommandInput, type GetQueueCommandOutput } from "../commands/GetQueueCommand";
 import type { DeadlineClient } from "../DeadlineClient";
+import type { DeadlineServiceException } from "../models/DeadlineServiceException";
 /**
  *
  *  @deprecated Use waitUntilQueueSchedulingBlocked instead. waitForQueueSchedulingBlocked does not throw error in non-success cases.
  */
-export declare const waitForQueueSchedulingBlocked: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueCommandInput) => Promise<WaiterResult>;
+export declare const waitForQueueSchedulingBlocked: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueCommandInput) => Promise<WaiterResult<GetQueueCommandOutput | DeadlineServiceException>>;
 /**
  *
  *  @param params - Waiter configuration options.
  *  @param input - The input to GetQueueCommand for polling.
  */
-export declare const waitUntilQueueSchedulingBlocked: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueCommandInput) => Promise<WaiterResult>;
+export declare const waitUntilQueueSchedulingBlocked: (params: WaiterConfiguration<DeadlineClient>, input: GetQueueCommandInput) => Promise<WaiterResult<GetQueueCommandOutput>>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-deadline",
   "description": "AWS SDK for JavaScript Deadline Client for Node.js, Browser and React Native",
-  "version": "3.1036.0",
+  "version": "3.1038.0",
   "scripts": {
     "build": "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
     "build:cjs": "node ../../scripts/compilation/inline client-deadline",
@@ -21,17 +21,17 @@
   "dependencies": {
     "@aws-crypto/sha256-browser": "5.2.0",
     "@aws-crypto/sha256-js": "5.2.0",
-    "@aws-sdk/core": "^3.974.5",
-    "@aws-sdk/credential-provider-node": "^3.972.36",
+    "@aws-sdk/core": "^3.974.6",
+    "@aws-sdk/credential-provider-node": "^3.972.37",
     "@aws-sdk/middleware-host-header": "^3.972.10",
     "@aws-sdk/middleware-logger": "^3.972.10",
     "@aws-sdk/middleware-recursion-detection": "^3.972.11",
-    "@aws-sdk/middleware-user-agent": "^3.972.35",
+    "@aws-sdk/middleware-user-agent": "^3.972.36",
     "@aws-sdk/region-config-resolver": "^3.972.13",
     "@aws-sdk/types": "^3.973.8",
     "@aws-sdk/util-endpoints": "^3.996.8",
     "@aws-sdk/util-user-agent-browser": "^3.972.10",
-    "@aws-sdk/util-user-agent-node": "^3.973.21",
+    "@aws-sdk/util-user-agent-node": "^3.973.22",
     "@smithy/config-resolver": "^4.4.17",
     "@smithy/core": "^3.23.17",
     "@smithy/fetch-http-handler": "^5.3.17",
@@ -39,7 +39,7 @@
     "@smithy/invalid-dependency": "^4.2.14",
     "@smithy/middleware-content-length": "^4.2.14",
     "@smithy/middleware-endpoint": "^4.4.32",
-    "@smithy/middleware-retry": "^4.5.5",
+    "@smithy/middleware-retry": "^4.5.6",
     "@smithy/middleware-serde": "^4.2.20",
     "@smithy/middleware-stack": "^4.2.14",
     "@smithy/node-config-provider": "^4.3.14",
@@ -55,9 +55,9 @@
     "@smithy/util-defaults-mode-node": "^4.2.54",
     "@smithy/util-endpoints": "^3.4.2",
     "@smithy/util-middleware": "^4.2.14",
-    "@smithy/util-retry": "^4.3.4",
+    "@smithy/util-retry": "^4.3.5",
     "@smithy/util-utf8": "^4.2.2",
-    "@smithy/util-waiter": "^4.2.16",
+    "@smithy/util-waiter": "^4.3.0",
     "tslib": "^2.6.2"
   },
   "devDependencies": {