@aws-sdk/client-deadline 3.731.1 → 3.737.0

package/dist-es/protocols/Aws_restJson1.js

@@ -349,6 +349,7 @@ export const se_CreateJobCommand = async (input, context) => {
         attachments: (_) => _json(_),
         maxFailedTasksCount: [],
         maxRetriesPerTask: [],
+        maxWorkerCount: [],
         parameters: (_) => _json(_),
         priority: [],
         sourceJobId: [],
@@ -393,6 +394,32 @@ export const se_CreateLicenseEndpointCommand = async (input, context) => {
     b.m("POST").h(headers).b(body);
     return b.build();
 };
+export const se_CreateLimitCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT] ?? generateIdempotencyToken(),
+    });
+    b.bp("/2023-10-12/farms/{farmId}/limits");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        amountRequirementName: [],
+        description: [],
+        displayName: [],
+        maxCount: [],
+    }));
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "management." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("POST").h(headers).b(body);
+    return b.build();
+};
 export const se_CreateMonitorCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
@@ -498,6 +525,29 @@ export const se_CreateQueueFleetAssociationCommand = async (input, context) => {
     b.m("PUT").h(headers).b(body);
     return b.build();
 };
+export const se_CreateQueueLimitAssociationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/queue-limit-associations");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        limitId: [],
+        queueId: [],
+    }));
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "management." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("PUT").h(headers).b(body);
+    return b.build();
+};
 export const se_CreateStorageProfileCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
@@ -619,6 +669,24 @@ export const se_DeleteLicenseEndpointCommand = async (input, context) => {
     b.m("DELETE").h(headers).b(body);
     return b.build();
 };
+export const se_DeleteLimitCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/limits/{limitId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("limitId", () => input.limitId, "{limitId}", false);
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "management." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
+};
 export const se_DeleteMeteredProductCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -710,6 +778,25 @@ export const se_DeleteQueueFleetAssociationCommand = async (input, context) => {
     b.m("DELETE").h(headers).b(body);
     return b.build();
 };
+export const se_DeleteQueueLimitAssociationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queue-limit-associations/{queueId}/{limitId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("limitId", () => input.limitId, "{limitId}", false);
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "management." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("DELETE").h(headers).b(body);
+    return b.build();
+};
 export const se_DeleteStorageProfileCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -881,8 +968,8 @@ export const se_GetJobCommand = async (input, context) => {
     const headers = {};
     b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}");
     b.p("farmId", () => input.farmId, "{farmId}", false);
-    b.p("jobId", () => input.jobId, "{jobId}", false);
     b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
     let body;
     let { hostname: resolvedHostname } = await context.endpoint();
     if (context.disableHostPrefix !== true) {
@@ -912,6 +999,24 @@ export const se_GetLicenseEndpointCommand = async (input, context) => {
     b.m("GET").h(headers).b(body);
     return b.build();
 };
+export const se_GetLimitCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/limits/{limitId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("limitId", () => input.limitId, "{limitId}", false);
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "management." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
+};
 export const se_GetMonitorCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -985,6 +1090,25 @@ export const se_GetQueueFleetAssociationCommand = async (input, context) => {
     b.m("GET").h(headers).b(body);
     return b.build();
 };
+export const se_GetQueueLimitAssociationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queue-limit-associations/{queueId}/{limitId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("limitId", () => input.limitId, "{limitId}", false);
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "management." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).b(body);
+    return b.build();
+};
 export const se_GetSessionCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -1363,6 +1487,27 @@ export const se_ListLicenseEndpointsCommand = async (input, context) => {
     b.m("GET").h(headers).q(query).b(body);
     return b.build();
 };
+export const se_ListLimitsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/limits");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    const query = map({
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    });
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "management." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_ListMeteredProductsCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -1449,6 +1594,29 @@ export const se_ListQueueFleetAssociationsCommand = async (input, context) => {
     b.m("GET").h(headers).q(query).b(body);
     return b.build();
 };
+export const se_ListQueueLimitAssociationsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queue-limit-associations");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    const query = map({
+        [_qI]: [, input[_qI]],
+        [_lI]: [, input[_lI]],
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+    });
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "management." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("GET").h(headers).q(query).b(body);
+    return b.build();
+};
 export const se_ListQueueMembersCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -2033,6 +2201,7 @@ export const se_UpdateJobCommand = async (input, context) => {
         lifecycleStatus: [],
         maxFailedTasksCount: [],
         maxRetriesPerTask: [],
+        maxWorkerCount: [],
         priority: [],
         targetTaskRunStatus: [],
     }));
@@ -2047,6 +2216,31 @@ export const se_UpdateJobCommand = async (input, context) => {
     b.m("PATCH").h(headers).b(body);
     return b.build();
 };
+export const se_UpdateLimitCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/limits/{limitId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("limitId", () => input.limitId, "{limitId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        description: [],
+        displayName: [],
+        maxCount: [],
+    }));
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "management." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
+};
 export const se_UpdateMonitorCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {
@@ -2155,6 +2349,30 @@ export const se_UpdateQueueFleetAssociationCommand = async (input, context) => {
     b.m("PATCH").h(headers).b(body);
     return b.build();
 };
+export const se_UpdateQueueLimitAssociationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/queue-limit-associations/{queueId}/{limitId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("limitId", () => input.limitId, "{limitId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        status: [],
+    }));
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "management." + resolvedHostname;
+        if (!__isValidHostname(resolvedHostname)) {
+            throw new Error("ValidationError: prefixed hostname must be hostname compatible.");
+        }
+    }
+    b.hn(resolvedHostname);
+    b.m("PATCH").h(headers).b(body);
+    return b.build();
+};
 export const se_UpdateSessionCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = map({}, isSerializableHeaderValue, {
@@ -2520,6 +2738,20 @@ export const de_CreateLicenseEndpointCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_CreateLimitCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        limitId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_CreateMonitorCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -2573,6 +2805,16 @@ export const de_CreateQueueFleetAssociationCommand = async (output, context) =>
     await collectBody(output.body, context);
     return contents;
 };
+export const de_CreateQueueLimitAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_CreateStorageProfileCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -2641,6 +2883,16 @@ export const de_DeleteLicenseEndpointCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
+export const de_DeleteLimitCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_DeleteMeteredProductCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -2691,6 +2943,16 @@ export const de_DeleteQueueFleetAssociationCommand = async (output, context) =>
     await collectBody(output.body, context);
     return contents;
 };
+export const de_DeleteQueueLimitAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_DeleteStorageProfileCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -2848,6 +3110,7 @@ export const de_GetJobCommand = async (output, context) => {
         lifecycleStatusMessage: __expectString,
         maxFailedTasksCount: __expectInt32,
         maxRetriesPerTask: __expectInt32,
+        maxWorkerCount: __expectInt32,
         name: __expectString,
         parameters: _json,
         priority: __expectInt32,
@@ -2883,6 +3146,30 @@ export const de_GetLicenseEndpointCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_GetLimitCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        amountRequirementName: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        currentCount: __expectInt32,
+        description: __expectString,
+        displayName: __expectString,
+        farmId: __expectString,
+        limitId: __expectString,
+        maxCount: __expectInt32,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_GetMonitorCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -2978,6 +3265,26 @@ export const de_GetQueueFleetAssociationCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_GetQueueLimitAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        limitId: __expectString,
+        queueId: __expectString,
+        status: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_GetSessionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -3012,6 +3319,7 @@ export const de_GetSessionActionCommand = async (output, context) => {
     });
     const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
     const doc = take(data, {
+        acquiredLimits: _json,
         definition: (_) => _json(__expectUnion(_)),
         endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
         processExitCode: __expectInt32,
@@ -3309,6 +3617,21 @@ export const de_ListLicenseEndpointsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_ListLimitsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        limits: (_) => de_LimitSummaries(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_ListMeteredProductsCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -3369,6 +3692,21 @@ export const de_ListQueueFleetAssociationsCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_ListQueueLimitAssociationsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        nextToken: __expectString,
+        queueLimitAssociations: (_) => de_QueueLimitAssociationSummaries(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_ListQueueMembersCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -3711,6 +4049,16 @@ export const de_UpdateJobCommand = async (output, context) => {
     await collectBody(output.body, context);
     return contents;
 };
+export const de_UpdateLimitCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_UpdateMonitorCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -3751,6 +4099,16 @@ export const de_UpdateQueueFleetAssociationCommand = async (output, context) =>
     await collectBody(output.body, context);
     return contents;
 };
+export const de_UpdateQueueLimitAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
 export const de_UpdateSessionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -4373,6 +4731,7 @@ const de_JobSearchSummary = (output, context) => {
         lifecycleStatusMessage: __expectString,
         maxFailedTasksCount: __expectInt32,
         maxRetriesPerTask: __expectInt32,
+        maxWorkerCount: __expectInt32,
         name: __expectString,
         priority: __expectInt32,
         queueId: __expectString,
@@ -4401,6 +4760,7 @@ const de_JobSummary = (output, context) => {
         lifecycleStatusMessage: __expectString,
         maxFailedTasksCount: __expectInt32,
         maxRetriesPerTask: __expectInt32,
+        maxWorkerCount: __expectInt32,
         name: __expectString,
         priority: __expectInt32,
         sourceJobId: __expectString,
@@ -4412,6 +4772,28 @@ const de_JobSummary = (output, context) => {
         updatedBy: __expectString,
     });
 };
+const de_LimitSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_LimitSummary(entry, context);
+    });
+    return retVal;
+};
+const de_LimitSummary = (output, context) => {
+    return take(output, {
+        amountRequirementName: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        currentCount: __expectInt32,
+        displayName: __expectString,
+        farmId: __expectString,
+        limitId: __expectString,
+        maxCount: __expectInt32,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+};
 const de_ListSessionsForWorkerSummaries = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -4462,6 +4844,25 @@ const de_QueueFleetAssociationSummary = (output, context) => {
         updatedBy: __expectString,
     });
 };
+const de_QueueLimitAssociationSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_QueueLimitAssociationSummary(entry, context);
+    });
+    return retVal;
+};
+const de_QueueLimitAssociationSummary = (output, context) => {
+    return take(output, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        limitId: __expectString,
+        queueId: __expectString,
+        status: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+};
 const de_QueueSummaries = (output, context) => {
     const retVal = (output || [])
         .filter((e) => e != null)
@@ -4784,6 +5185,7 @@ const _aI = "aggregationId";
 const _cT = "clientToken";
 const _dN = "displayName";
 const _fI = "fleetId";
+const _lI = "limitId";
 const _mR = "maxResults";
 const _nT = "nextToken";
 const _pI = "principalId";

package/dist-es/waiters/index.js

@@ -3,5 +3,6 @@ export * from "./waitForJobCreateComplete";
 export * from "./waitForLicenseEndpointDeleted";
 export * from "./waitForLicenseEndpointValid";
 export * from "./waitForQueueFleetAssociationStopped";
+export * from "./waitForQueueLimitAssociationStopped";
 export * from "./waitForQueueScheduling";
 export * from "./waitForQueueSchedulingBlocked";

package/dist-es/waiters/waitForQueueLimitAssociationStopped.js

@@ -0,0 +1,31 @@
+import { checkExceptions, createWaiter, WaiterState } from "@smithy/util-waiter";
+import { GetQueueLimitAssociationCommand, } from "../commands/GetQueueLimitAssociationCommand";
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetQueueLimitAssociationCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.status;
+            };
+            if (returnComparator() === "STOPPED") {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+export const waitForQueueLimitAssociationStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 600 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+export const waitUntilQueueLimitAssociationStopped = async (params, input) => {
+    const serviceDefaults = { minDelay: 10, maxDelay: 600 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return checkExceptions(result);
+};