@aws-sdk/client-deadline 3.546.0

package/dist-es/protocols/Aws_restJson1.js

@@ -0,0 +1,4749 @@
+import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
+import { requestBuilder as rb } from "@smithy/core";
+import { isValidHostname as __isValidHostname, } from "@smithy/protocol-http";
+import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, limitedParseFloat32 as __limitedParseFloat32, map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeFloat as __serializeFloat, strictParseInt32 as __strictParseInt32, take, withBaseException, } from "@smithy/smithy-client";
+import { DeadlineServiceException as __BaseException } from "../models/DeadlineServiceException";
+import { AccessDeniedException, BudgetSchedule, ConflictException, FleetConfiguration, InternalServerErrorException, ResourceNotFoundException, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { SearchFilterExpression, } from "../models/models_1";
+export const se_AssociateMemberToFarmCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/members/{principalId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("principalId", () => input.principalId, "{principalId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        identityStoreId: [],
+        membershipLevel: [],
+        principalType: [],
+    }));
+    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_AssociateMemberToFleetCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/members/{principalId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    b.p("principalId", () => input.principalId, "{principalId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        identityStoreId: [],
+        membershipLevel: [],
+        principalType: [],
+    }));
+    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_AssociateMemberToJobCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/members/{principalId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("principalId", () => input.principalId, "{principalId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        identityStoreId: [],
+        membershipLevel: [],
+        principalType: [],
+    }));
+    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_AssociateMemberToQueueCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/members/{principalId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("principalId", () => input.principalId, "{principalId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        identityStoreId: [],
+        membershipLevel: [],
+        principalType: [],
+    }));
+    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_AssumeFleetRoleForReadCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/read-roles");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", 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_AssumeFleetRoleForWorkerCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/workers/{workerId}/fleet-roles");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    b.p("workerId", () => input.workerId, "{workerId}", false);
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "scheduling." + 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_AssumeQueueRoleForReadCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/read-roles");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", 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_AssumeQueueRoleForUserCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/user-roles");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", 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_AssumeQueueRoleForWorkerCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/workers/{workerId}/queue-roles");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    b.p("workerId", () => input.workerId, "{workerId}", false);
+    const query = map({
+        [_qI]: [, __expectNonNull(input[_qI], `queueId`)],
+    });
+    let body;
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "scheduling." + 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_BatchGetJobEntityCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/workers/{workerId}/batchGetJobEntity");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    b.p("workerId", () => input.workerId, "{workerId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        identifiers: (_) => _json(_),
+    }));
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "scheduling." + 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_CopyJobTemplateCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/template");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        targetS3Location: (_) => _json(_),
+    }));
+    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_CreateBudgetCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/budgets");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        actions: (_) => se_BudgetActionsToAdd(_, context),
+        approximateDollarLimit: (_) => __serializeFloat(_),
+        description: [],
+        displayName: [],
+        schedule: (_) => se_BudgetSchedule(_, context),
+        usageTrackingResource: (_) => _json(_),
+    }));
+    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_CreateFarmCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms");
+    let body;
+    body = JSON.stringify(take(input, {
+        description: [],
+        displayName: [],
+        kmsKeyArn: [],
+        tags: (_) => _json(_),
+    }));
+    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_CreateFleetCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/fleets");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        configuration: (_) => se_FleetConfiguration(_, context),
+        description: [],
+        displayName: [],
+        maxWorkerCount: [],
+        minWorkerCount: [],
+        roleArn: [],
+        tags: (_) => _json(_),
+    }));
+    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_CreateJobCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        attachments: (_) => _json(_),
+        maxFailedTasksCount: [],
+        maxRetriesPerTask: [],
+        parameters: (_) => _json(_),
+        priority: [],
+        storageProfileId: [],
+        targetTaskRunStatus: [],
+        template: [],
+        templateType: [],
+    }));
+    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_CreateLicenseEndpointCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/license-endpoints");
+    let body;
+    body = JSON.stringify(take(input, {
+        securityGroupIds: (_) => _json(_),
+        subnetIds: (_) => _json(_),
+        tags: (_) => _json(_),
+        vpcId: [],
+    }));
+    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, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/monitors");
+    let body;
+    body = JSON.stringify(take(input, {
+        displayName: [],
+        identityCenterInstanceArn: [],
+        roleArn: [],
+        subdomain: [],
+    }));
+    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_CreateQueueCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/queues");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        allowedStorageProfileIds: (_) => _json(_),
+        defaultBudgetAction: [],
+        description: [],
+        displayName: [],
+        jobAttachmentSettings: (_) => _json(_),
+        jobRunAsUser: (_) => _json(_),
+        requiredFileSystemLocationNames: (_) => _json(_),
+        roleArn: [],
+        tags: (_) => _json(_),
+    }));
+    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_CreateQueueEnvironmentCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/environments");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        priority: [],
+        template: [],
+        templateType: [],
+    }));
+    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_CreateQueueFleetAssociationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/queue-fleet-associations");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        fleetId: [],
+        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, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/storage-profiles");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        displayName: [],
+        fileSystemLocations: (_) => _json(_),
+        osFamily: [],
+    }));
+    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_CreateWorkerCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/workers");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        hostProperties: (_) => _json(_),
+    }));
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "scheduling." + 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_DeleteBudgetCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/budgets/{budgetId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("budgetId", () => input.budgetId, "{budgetId}", 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_DeleteFarmCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}");
+    b.p("farmId", () => input.farmId, "{farmId}", 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_DeleteFleetCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", 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_DeleteLicenseEndpointCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/license-endpoints/{licenseEndpointId}");
+    b.p("licenseEndpointId", () => input.licenseEndpointId, "{licenseEndpointId}", 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 = {};
+    b.bp("/2023-10-12/license-endpoints/{licenseEndpointId}/metered-products/{productId}");
+    b.p("licenseEndpointId", () => input.licenseEndpointId, "{licenseEndpointId}", false);
+    b.p("productId", () => input.productId, "{productId}", 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_DeleteMonitorCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/monitors/{monitorId}");
+    b.p("monitorId", () => input.monitorId, "{monitorId}", 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_DeleteQueueCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", 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_DeleteQueueEnvironmentCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/environments/{queueEnvironmentId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("queueEnvironmentId", () => input.queueEnvironmentId, "{queueEnvironmentId}", 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_DeleteQueueFleetAssociationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queue-fleet-associations/{queueId}/{fleetId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", 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 = {};
+    b.bp("/2023-10-12/farms/{farmId}/storage-profiles/{storageProfileId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("storageProfileId", () => input.storageProfileId, "{storageProfileId}", 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_DeleteWorkerCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/workers/{workerId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    b.p("workerId", () => input.workerId, "{workerId}", 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_DisassociateMemberFromFarmCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/members/{principalId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("principalId", () => input.principalId, "{principalId}", 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_DisassociateMemberFromFleetCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/members/{principalId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    b.p("principalId", () => input.principalId, "{principalId}", 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_DisassociateMemberFromJobCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/members/{principalId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("principalId", () => input.principalId, "{principalId}", 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_DisassociateMemberFromQueueCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/members/{principalId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("principalId", () => input.principalId, "{principalId}", 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_GetBudgetCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/budgets/{budgetId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("budgetId", () => input.budgetId, "{budgetId}", 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_GetFarmCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}");
+    b.p("farmId", () => input.farmId, "{farmId}", 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_GetFleetCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", 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_GetJobCommand = async (input, context) => {
+    const b = rb(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);
+    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_GetLicenseEndpointCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/license-endpoints/{licenseEndpointId}");
+    b.p("licenseEndpointId", () => input.licenseEndpointId, "{licenseEndpointId}", 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 = {};
+    b.bp("/2023-10-12/monitors/{monitorId}");
+    b.p("monitorId", () => input.monitorId, "{monitorId}", 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_GetQueueCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", 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_GetQueueEnvironmentCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/environments/{queueEnvironmentId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("queueEnvironmentId", () => input.queueEnvironmentId, "{queueEnvironmentId}", 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_GetQueueFleetAssociationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queue-fleet-associations/{queueId}/{fleetId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", 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 = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/sessions/{sessionId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("sessionId", () => input.sessionId, "{sessionId}", 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_GetSessionActionCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/session-actions/{sessionActionId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("sessionActionId", () => input.sessionActionId, "{sessionActionId}", 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_GetSessionsStatisticsAggregationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/sessions-statistics-aggregation");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    const query = map({
+        [_aI]: [, __expectNonNull(input[_aI], `aggregationId`)],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_nT]: [, input[_nT]],
+    });
+    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_GetStepCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/steps/{stepId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("stepId", () => input.stepId, "{stepId}", 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_GetStorageProfileCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/storage-profiles/{storageProfileId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("storageProfileId", () => input.storageProfileId, "{storageProfileId}", 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_GetStorageProfileForQueueCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/storage-profiles/{storageProfileId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("storageProfileId", () => input.storageProfileId, "{storageProfileId}", 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_GetTaskCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/steps/{stepId}/tasks/{taskId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("stepId", () => input.stepId, "{stepId}", false);
+    b.p("taskId", () => input.taskId, "{taskId}", 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_GetWorkerCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/workers/{workerId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    b.p("workerId", () => input.workerId, "{workerId}", 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_ListAvailableMeteredProductsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/metered-products");
+    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_ListBudgetsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/budgets");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    const query = map({
+        [_nT]: [, input[_nT]],
+        [_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
+        [_s]: [, input[_s]],
+    });
+    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_ListFarmMembersCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/members");
+    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_ListFarmsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms");
+    const query = map({
+        [_nT]: [, input[_nT]],
+        [_pI]: [, input[_pI]],
+        [_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_ListFleetMembersCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/members");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", 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_ListFleetsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/fleets");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    const query = map({
+        [_pI]: [, input[_pI]],
+        [_dN]: [, input[_dN]],
+        [_s]: [, input[_s]],
+        [_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_ListJobMembersCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/members");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", 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_ListJobsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    const query = map({
+        [_pI]: [, input[_pI]],
+        [_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_ListLicenseEndpointsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/license-endpoints");
+    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 = {};
+    b.bp("/2023-10-12/license-endpoints/{licenseEndpointId}/metered-products");
+    b.p("licenseEndpointId", () => input.licenseEndpointId, "{licenseEndpointId}", 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_ListMonitorsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/monitors");
+    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_ListQueueEnvironmentsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/environments");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", 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_ListQueueFleetAssociationsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queue-fleet-associations");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    const query = map({
+        [_qI]: [, input[_qI]],
+        [_fI]: [, input[_fI]],
+        [_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 = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/members");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", 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_ListQueuesCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    const query = map({
+        [_pI]: [, input[_pI]],
+        [_s]: [, input[_s]],
+        [_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_ListSessionActionsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/session-actions");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    const query = map({
+        [_sI]: [, input[_sI]],
+        [_tI]: [, input[_tI]],
+        [_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_ListSessionsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/sessions");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", 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_ListSessionsForWorkerCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/workers/{workerId}/sessions");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    b.p("workerId", () => input.workerId, "{workerId}", 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_ListStepConsumersCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/steps/{stepId}/consumers");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("stepId", () => input.stepId, "{stepId}", 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_ListStepDependenciesCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/steps/{stepId}/dependencies");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("stepId", () => input.stepId, "{stepId}", 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_ListStepsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/steps");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", 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_ListStorageProfilesCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/storage-profiles");
+    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_ListStorageProfilesForQueueCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/storage-profiles");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", 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_ListTagsForResourceCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", 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_ListTasksCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/steps/{stepId}/tasks");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("stepId", () => input.stepId, "{stepId}", 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_ListWorkersCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/workers");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", 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_PutMeteredProductCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/license-endpoints/{licenseEndpointId}/metered-products/{productId}");
+    b.p("licenseEndpointId", () => input.licenseEndpointId, "{licenseEndpointId}", false);
+    b.p("productId", () => input.productId, "{productId}", 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("PUT").h(headers).b(body);
+    return b.build();
+};
+export const se_SearchJobsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/search/jobs");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        filterExpressions: (_) => se_SearchGroupedFilterExpressions(_, context),
+        itemOffset: [],
+        pageSize: [],
+        queueIds: (_) => _json(_),
+        sortExpressions: (_) => _json(_),
+    }));
+    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_SearchStepsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/search/steps");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        filterExpressions: (_) => se_SearchGroupedFilterExpressions(_, context),
+        itemOffset: [],
+        jobId: [],
+        pageSize: [],
+        queueIds: (_) => _json(_),
+        sortExpressions: (_) => _json(_),
+    }));
+    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_SearchTasksCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/search/tasks");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        filterExpressions: (_) => se_SearchGroupedFilterExpressions(_, context),
+        itemOffset: [],
+        jobId: [],
+        pageSize: [],
+        queueIds: (_) => _json(_),
+        sortExpressions: (_) => _json(_),
+    }));
+    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_SearchWorkersCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/search/workers");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        filterExpressions: (_) => se_SearchGroupedFilterExpressions(_, context),
+        fleetIds: (_) => _json(_),
+        itemOffset: [],
+        pageSize: [],
+        sortExpressions: (_) => _json(_),
+    }));
+    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_StartSessionsStatisticsAggregationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/sessions-statistics-aggregation");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        endTime: (_) => _.toISOString().split(".")[0] + "Z",
+        groupBy: (_) => _json(_),
+        period: [],
+        resourceIds: (_) => _json(_),
+        startTime: (_) => _.toISOString().split(".")[0] + "Z",
+        statistics: (_) => _json(_),
+        timezone: [],
+    }));
+    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_TagResourceCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        tags: (_) => _json(_),
+    }));
+    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_UntagResourceCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/2023-10-12/tags/{resourceArn}");
+    b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    const query = map({
+        [_tK]: [
+            __expectNonNull(input.tagKeys, `tagKeys`) != null,
+            () => (input[_tK] || []).map((_entry) => _entry),
+        ],
+    });
+    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).q(query).b(body);
+    return b.build();
+};
+export const se_UpdateBudgetCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/budgets/{budgetId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("budgetId", () => input.budgetId, "{budgetId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        actionsToAdd: (_) => se_BudgetActionsToAdd(_, context),
+        actionsToRemove: (_) => se_BudgetActionsToRemove(_, context),
+        approximateDollarLimit: (_) => __serializeFloat(_),
+        description: [],
+        displayName: [],
+        schedule: (_) => se_BudgetSchedule(_, context),
+        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_UpdateFarmCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        description: [],
+        displayName: [],
+    }));
+    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_UpdateFleetCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        configuration: (_) => se_FleetConfiguration(_, context),
+        description: [],
+        displayName: [],
+        maxWorkerCount: [],
+        minWorkerCount: [],
+        roleArn: [],
+    }));
+    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_UpdateJobCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        lifecycleStatus: [],
+        maxFailedTasksCount: [],
+        maxRetriesPerTask: [],
+        priority: [],
+        targetTaskRunStatus: [],
+    }));
+    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 = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/monitors/{monitorId}");
+    b.p("monitorId", () => input.monitorId, "{monitorId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        displayName: [],
+        roleArn: [],
+        subdomain: [],
+    }));
+    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_UpdateQueueCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        allowedStorageProfileIdsToAdd: (_) => _json(_),
+        allowedStorageProfileIdsToRemove: (_) => _json(_),
+        defaultBudgetAction: [],
+        description: [],
+        displayName: [],
+        jobAttachmentSettings: (_) => _json(_),
+        jobRunAsUser: (_) => _json(_),
+        requiredFileSystemLocationNamesToAdd: (_) => _json(_),
+        requiredFileSystemLocationNamesToRemove: (_) => _json(_),
+        roleArn: [],
+    }));
+    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_UpdateQueueEnvironmentCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/environments/{queueEnvironmentId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("queueEnvironmentId", () => input.queueEnvironmentId, "{queueEnvironmentId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        priority: [],
+        template: [],
+        templateType: [],
+    }));
+    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_UpdateQueueFleetAssociationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/queue-fleet-associations/{queueId}/{fleetId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", 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, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/sessions/{sessionId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("sessionId", () => input.sessionId, "{sessionId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        targetLifecycleStatus: [],
+    }));
+    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_UpdateStepCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/steps/{stepId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("stepId", () => input.stepId, "{stepId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        targetTaskRunStatus: [],
+    }));
+    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_UpdateStorageProfileCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/storage-profiles/{storageProfileId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("storageProfileId", () => input.storageProfileId, "{storageProfileId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        displayName: [],
+        fileSystemLocationsToAdd: (_) => _json(_),
+        fileSystemLocationsToRemove: (_) => _json(_),
+        osFamily: [],
+    }));
+    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_UpdateTaskCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        "content-type": "application/json",
+        [_xact]: input[_cT],
+    });
+    b.bp("/2023-10-12/farms/{farmId}/queues/{queueId}/jobs/{jobId}/steps/{stepId}/tasks/{taskId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("queueId", () => input.queueId, "{queueId}", false);
+    b.p("jobId", () => input.jobId, "{jobId}", false);
+    b.p("stepId", () => input.stepId, "{stepId}", false);
+    b.p("taskId", () => input.taskId, "{taskId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        targetRunStatus: [],
+    }));
+    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_UpdateWorkerCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/workers/{workerId}");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    b.p("workerId", () => input.workerId, "{workerId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        capabilities: (_) => se_WorkerCapabilities(_, context),
+        hostProperties: (_) => _json(_),
+        status: [],
+    }));
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "scheduling." + 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_UpdateWorkerScheduleCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        "content-type": "application/json",
+    };
+    b.bp("/2023-10-12/farms/{farmId}/fleets/{fleetId}/workers/{workerId}/schedule");
+    b.p("farmId", () => input.farmId, "{farmId}", false);
+    b.p("fleetId", () => input.fleetId, "{fleetId}", false);
+    b.p("workerId", () => input.workerId, "{workerId}", false);
+    let body;
+    body = JSON.stringify(take(input, {
+        updatedSessionActions: (_) => se_UpdatedSessionActions(_, context),
+    }));
+    let { hostname: resolvedHostname } = await context.endpoint();
+    if (context.disableHostPrefix !== true) {
+        resolvedHostname = "scheduling." + 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 de_AssociateMemberToFarmCommand = 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_AssociateMemberToFleetCommand = 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_AssociateMemberToJobCommand = 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_AssociateMemberToQueueCommand = 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_AssumeFleetRoleForReadCommand = 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, {
+        credentials: (_) => de_AwsCredentials(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_AssumeFleetRoleForWorkerCommand = 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, {
+        credentials: (_) => de_AwsCredentials(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_AssumeQueueRoleForReadCommand = 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, {
+        credentials: (_) => de_AwsCredentials(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_AssumeQueueRoleForUserCommand = 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, {
+        credentials: (_) => de_AwsCredentials(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_AssumeQueueRoleForWorkerCommand = 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, {
+        credentials: (_) => de_AwsCredentials(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_BatchGetJobEntityCommand = 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, {
+        entities: (_) => de_BatchGetJobEntityList(_, context),
+        errors: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CopyJobTemplateCommand = 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, {
+        templateType: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateBudgetCommand = 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, {
+        budgetId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateFarmCommand = 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, {
+        farmId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateFleetCommand = 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, {
+        fleetId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateJobCommand = async (output, context) => {
+    if (output.statusCode !== 201 && 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, {
+        jobId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateLicenseEndpointCommand = 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, {
+        licenseEndpointId: __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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        identityCenterApplicationArn: __expectString,
+        monitorId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateQueueCommand = 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, {
+        queueId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateQueueEnvironmentCommand = 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, {
+        queueEnvironmentId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateQueueFleetAssociationCommand = 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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        storageProfileId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateWorkerCommand = 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, {
+        workerId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_DeleteBudgetCommand = 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_DeleteFarmCommand = 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_DeleteFleetCommand = 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_DeleteLicenseEndpointCommand = 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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+export const de_DeleteMonitorCommand = 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_DeleteQueueCommand = 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_DeleteQueueEnvironmentCommand = 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_DeleteQueueFleetAssociationCommand = 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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+export const de_DeleteWorkerCommand = 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_DisassociateMemberFromFarmCommand = 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_DisassociateMemberFromFleetCommand = 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_DisassociateMemberFromJobCommand = 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_DisassociateMemberFromQueueCommand = 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_GetBudgetCommand = 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, {
+        actions: (_) => de_ResponseBudgetActionList(_, context),
+        approximateDollarLimit: __limitedParseFloat32,
+        budgetId: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        description: __expectString,
+        displayName: __expectString,
+        queueStoppedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        schedule: (_) => de_BudgetSchedule(__expectUnion(_), context),
+        status: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+        usageTrackingResource: (_) => _json(__expectUnion(_)),
+        usages: (_) => de_ConsumedUsages(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetFarmCommand = 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,
+        description: __expectString,
+        displayName: __expectString,
+        farmId: __expectString,
+        kmsKeyArn: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetFleetCommand = 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, {
+        autoScalingStatus: __expectString,
+        capabilities: (_) => de_FleetCapabilities(_, context),
+        configuration: (_) => de_FleetConfiguration(__expectUnion(_), context),
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        description: __expectString,
+        displayName: __expectString,
+        farmId: __expectString,
+        fleetId: __expectString,
+        maxWorkerCount: __expectInt32,
+        minWorkerCount: __expectInt32,
+        roleArn: __expectString,
+        status: __expectString,
+        targetWorkerCount: __expectInt32,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+        workerCount: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetJobCommand = 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, {
+        attachments: _json,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        description: __expectString,
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        jobId: __expectString,
+        lifecycleStatus: __expectString,
+        lifecycleStatusMessage: __expectString,
+        maxFailedTasksCount: __expectInt32,
+        maxRetriesPerTask: __expectInt32,
+        name: __expectString,
+        parameters: _json,
+        priority: __expectInt32,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        storageProfileId: __expectString,
+        targetTaskRunStatus: __expectString,
+        taskRunStatus: __expectString,
+        taskRunStatusCounts: _json,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetLicenseEndpointCommand = 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, {
+        dnsName: __expectString,
+        licenseEndpointId: __expectString,
+        securityGroupIds: _json,
+        status: __expectString,
+        statusMessage: __expectString,
+        subnetIds: _json,
+        vpcId: __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);
+    }
+    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,
+        displayName: __expectString,
+        identityCenterApplicationArn: __expectString,
+        identityCenterInstanceArn: __expectString,
+        monitorId: __expectString,
+        roleArn: __expectString,
+        subdomain: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+        url: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetQueueCommand = 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, {
+        allowedStorageProfileIds: _json,
+        blockedReason: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        defaultBudgetAction: __expectString,
+        description: __expectString,
+        displayName: __expectString,
+        farmId: __expectString,
+        jobAttachmentSettings: _json,
+        jobRunAsUser: _json,
+        queueId: __expectString,
+        requiredFileSystemLocationNames: _json,
+        roleArn: __expectString,
+        status: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetQueueEnvironmentCommand = 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,
+        name: __expectString,
+        priority: __expectInt32,
+        queueEnvironmentId: __expectString,
+        template: __expectString,
+        templateType: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetQueueFleetAssociationCommand = 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,
+        fleetId: __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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        fleetId: __expectString,
+        hostProperties: _json,
+        lifecycleStatus: __expectString,
+        log: _json,
+        sessionId: __expectString,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        targetLifecycleStatus: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+        workerId: __expectString,
+        workerLog: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetSessionActionCommand = 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, {
+        definition: (_) => _json(__expectUnion(_)),
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        processExitCode: __expectInt32,
+        progressMessage: __expectString,
+        progressPercent: __limitedParseFloat32,
+        sessionActionId: __expectString,
+        sessionId: __expectString,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        status: __expectString,
+        workerUpdatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetSessionsStatisticsAggregationCommand = 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,
+        statistics: (_) => de_StatisticsList(_, context),
+        status: __expectString,
+        statusMessage: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetStepCommand = 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,
+        dependencyCounts: _json,
+        description: __expectString,
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        lifecycleStatus: __expectString,
+        lifecycleStatusMessage: __expectString,
+        name: __expectString,
+        parameterSpace: _json,
+        requiredCapabilities: (_) => de_StepRequiredCapabilities(_, context),
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        stepId: __expectString,
+        targetTaskRunStatus: __expectString,
+        taskRunStatus: __expectString,
+        taskRunStatusCounts: _json,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetStorageProfileCommand = 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,
+        displayName: __expectString,
+        fileSystemLocations: _json,
+        osFamily: __expectString,
+        storageProfileId: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetStorageProfileForQueueCommand = 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, {
+        displayName: __expectString,
+        fileSystemLocations: _json,
+        osFamily: __expectString,
+        storageProfileId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetTaskCommand = 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,
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        failureRetryCount: __expectInt32,
+        latestSessionActionId: __expectString,
+        parameters: _json,
+        runStatus: __expectString,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        targetRunStatus: __expectString,
+        taskId: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetWorkerCommand = 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,
+        farmId: __expectString,
+        fleetId: __expectString,
+        hostProperties: _json,
+        log: _json,
+        status: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+        workerId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListAvailableMeteredProductsCommand = 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, {
+        meteredProducts: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListBudgetsCommand = 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, {
+        budgets: (_) => de_BudgetSummaries(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListFarmMembersCommand = 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, {
+        members: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListFarmsCommand = 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, {
+        farms: (_) => de_FarmSummaries(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListFleetMembersCommand = 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, {
+        members: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListFleetsCommand = 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, {
+        fleets: (_) => de_FleetSummaries(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListJobMembersCommand = 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, {
+        members: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListJobsCommand = 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, {
+        jobs: (_) => de_JobSummaries(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListLicenseEndpointsCommand = 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, {
+        licenseEndpoints: _json,
+        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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        meteredProducts: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListMonitorsCommand = 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, {
+        monitors: (_) => de_MonitorSummaries(_, context),
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListQueueEnvironmentsCommand = 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, {
+        environments: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListQueueFleetAssociationsCommand = 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,
+        queueFleetAssociations: (_) => de_QueueFleetAssociationSummaries(_, 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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    const doc = take(data, {
+        members: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListQueuesCommand = 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,
+        queues: (_) => de_QueueSummaries(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListSessionActionsCommand = 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,
+        sessionActions: (_) => de_SessionActionSummaries(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListSessionsCommand = 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,
+        sessions: (_) => de_SessionSummaries(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListSessionsForWorkerCommand = 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,
+        sessions: (_) => de_ListSessionsForWorkerSummaries(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListStepConsumersCommand = 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, {
+        consumers: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListStepDependenciesCommand = 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, {
+        dependencies: _json,
+        nextToken: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListStepsCommand = 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,
+        steps: (_) => de_StepSummaries(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListStorageProfilesCommand = 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,
+        storageProfiles: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListStorageProfilesForQueueCommand = 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,
+        storageProfiles: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListTagsForResourceCommand = 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, {
+        tags: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListTasksCommand = 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,
+        tasks: (_) => de_TaskSummaries(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListWorkersCommand = 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,
+        workers: (_) => de_WorkerSummaries(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_PutMeteredProductCommand = 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_SearchJobsCommand = 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, {
+        jobs: (_) => de_JobSearchSummaries(_, context),
+        nextItemOffset: __expectInt32,
+        totalResults: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_SearchStepsCommand = 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, {
+        nextItemOffset: __expectInt32,
+        steps: (_) => de_StepSearchSummaries(_, context),
+        totalResults: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_SearchTasksCommand = 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, {
+        nextItemOffset: __expectInt32,
+        tasks: (_) => de_TaskSearchSummaries(_, context),
+        totalResults: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_SearchWorkersCommand = 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, {
+        nextItemOffset: __expectInt32,
+        totalResults: __expectInt32,
+        workers: (_) => de_WorkerSearchSummaries(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_StartSessionsStatisticsAggregationCommand = 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, {
+        aggregationId: __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_TagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+export const de_UntagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+export const de_UpdateBudgetCommand = 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_UpdateFarmCommand = 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_UpdateFleetCommand = 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_UpdateJobCommand = 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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+export const de_UpdateQueueCommand = 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_UpdateQueueEnvironmentCommand = 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_UpdateQueueFleetAssociationCommand = 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);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+export const de_UpdateStepCommand = 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_UpdateStorageProfileCommand = 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_UpdateTaskCommand = 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_UpdateWorkerCommand = 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, {
+        log: _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_UpdateWorkerScheduleCommand = 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, {
+        assignedSessions: _json,
+        cancelSessionActions: _json,
+        desiredWorkerStatus: __expectString,
+        updateIntervalSeconds: __expectInt32,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+const de_CommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.deadline#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerErrorException":
+        case "com.amazonaws.deadline#InternalServerErrorException":
+            throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.deadline#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.deadline#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.deadline#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.deadline#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.deadline#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+const throwDefaultError = withBaseException(__BaseException);
+const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        context: _json,
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new AccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ConflictExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        context: _json,
+        message: __expectString,
+        reason: __expectString,
+        resourceId: __expectString,
+        resourceType: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
+    const contents = map({
+        [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => __strictParseInt32(parsedOutput.headers[_ra])],
+    });
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InternalServerErrorException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        context: _json,
+        message: __expectString,
+        resourceId: __expectString,
+        resourceType: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        context: _json,
+        message: __expectString,
+        quotaCode: __expectString,
+        reason: __expectString,
+        resourceId: __expectString,
+        resourceType: __expectString,
+        serviceCode: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ServiceQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
+    const contents = map({
+        [_rAS]: [() => void 0 !== parsedOutput.headers[_ra], () => __strictParseInt32(parsedOutput.headers[_ra])],
+    });
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        context: _json,
+        message: __expectString,
+        quotaCode: __expectString,
+        serviceCode: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ThrottlingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ValidationExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        context: _json,
+        fieldList: _json,
+        message: __expectString,
+        reason: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ValidationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const se_BudgetActionsToAdd = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_BudgetActionToAdd(entry, context);
+    });
+};
+const se_BudgetActionsToRemove = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_BudgetActionToRemove(entry, context);
+    });
+};
+const se_BudgetActionToAdd = (input, context) => {
+    return take(input, {
+        description: [],
+        thresholdPercentage: __serializeFloat,
+        type: [],
+    });
+};
+const se_BudgetActionToRemove = (input, context) => {
+    return take(input, {
+        thresholdPercentage: __serializeFloat,
+        type: [],
+    });
+};
+const se_BudgetSchedule = (input, context) => {
+    return BudgetSchedule.visit(input, {
+        fixed: (value) => ({ fixed: se_FixedBudgetSchedule(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_CustomerManagedFleetConfiguration = (input, context) => {
+    return take(input, {
+        mode: [],
+        storageProfileId: [],
+        workerCapabilities: (_) => se_CustomerManagedWorkerCapabilities(_, context),
+    });
+};
+const se_CustomerManagedWorkerCapabilities = (input, context) => {
+    return take(input, {
+        acceleratorCount: _json,
+        acceleratorTotalMemoryMiB: _json,
+        acceleratorTypes: _json,
+        cpuArchitectureType: [],
+        customAmounts: (_) => se_CustomFleetAmountCapabilities(_, context),
+        customAttributes: _json,
+        memoryMiB: _json,
+        osFamily: [],
+        vCpuCount: _json,
+    });
+};
+const se_CustomFleetAmountCapabilities = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_FleetAmountCapability(entry, context);
+    });
+};
+const se_DateTimeFilterExpression = (input, context) => {
+    return take(input, {
+        dateTime: (_) => _.toISOString().split(".")[0] + "Z",
+        name: [],
+        operator: [],
+    });
+};
+const se_FixedBudgetSchedule = (input, context) => {
+    return take(input, {
+        endTime: (_) => _.toISOString().split(".")[0] + "Z",
+        startTime: (_) => _.toISOString().split(".")[0] + "Z",
+    });
+};
+const se_FleetAmountCapability = (input, context) => {
+    return take(input, {
+        max: __serializeFloat,
+        min: __serializeFloat,
+        name: [],
+    });
+};
+const se_FleetConfiguration = (input, context) => {
+    return FleetConfiguration.visit(input, {
+        customerManaged: (value) => ({ customerManaged: se_CustomerManagedFleetConfiguration(value, context) }),
+        serviceManagedEc2: (value) => ({ serviceManagedEc2: se_ServiceManagedEc2FleetConfiguration(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_SearchFilterExpression = (input, context) => {
+    return SearchFilterExpression.visit(input, {
+        dateTimeFilter: (value) => ({ dateTimeFilter: se_DateTimeFilterExpression(value, context) }),
+        groupFilter: (value) => ({ groupFilter: se_SearchGroupedFilterExpressions(value, context) }),
+        parameterFilter: (value) => ({ parameterFilter: _json(value) }),
+        searchTermFilter: (value) => ({ searchTermFilter: _json(value) }),
+        stringFilter: (value) => ({ stringFilter: _json(value) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const se_SearchFilterExpressions = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_SearchFilterExpression(entry, context);
+    });
+};
+const se_SearchGroupedFilterExpressions = (input, context) => {
+    return take(input, {
+        filters: (_) => se_SearchFilterExpressions(_, context),
+        operator: [],
+    });
+};
+const se_ServiceManagedEc2FleetConfiguration = (input, context) => {
+    return take(input, {
+        instanceCapabilities: (_) => se_ServiceManagedEc2InstanceCapabilities(_, context),
+        instanceMarketOptions: _json,
+    });
+};
+const se_ServiceManagedEc2InstanceCapabilities = (input, context) => {
+    return take(input, {
+        allowedInstanceTypes: _json,
+        cpuArchitectureType: [],
+        customAmounts: (_) => se_CustomFleetAmountCapabilities(_, context),
+        customAttributes: _json,
+        excludedInstanceTypes: _json,
+        memoryMiB: _json,
+        osFamily: [],
+        rootEbsVolume: _json,
+        vCpuCount: _json,
+    });
+};
+const se_UpdatedSessionActionInfo = (input, context) => {
+    return take(input, {
+        completedStatus: [],
+        endedAt: (_) => _.toISOString().split(".")[0] + "Z",
+        processExitCode: [],
+        progressMessage: [],
+        progressPercent: __serializeFloat,
+        startedAt: (_) => _.toISOString().split(".")[0] + "Z",
+        updatedAt: (_) => _.toISOString().split(".")[0] + "Z",
+    });
+};
+const se_UpdatedSessionActions = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = se_UpdatedSessionActionInfo(value, context);
+        return acc;
+    }, {});
+};
+const se_WorkerAmountCapability = (input, context) => {
+    return take(input, {
+        name: [],
+        value: __serializeFloat,
+    });
+};
+const se_WorkerAmountCapabilityList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return se_WorkerAmountCapability(entry, context);
+    });
+};
+const se_WorkerCapabilities = (input, context) => {
+    return take(input, {
+        amounts: (_) => se_WorkerAmountCapabilityList(_, context),
+        attributes: _json,
+    });
+};
+const de_AwsCredentials = (output, context) => {
+    return take(output, {
+        accessKeyId: __expectString,
+        expiration: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        secretAccessKey: __expectString,
+        sessionToken: __expectString,
+    });
+};
+const de_BatchGetJobEntityList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_JobEntity(__expectUnion(entry), context);
+    });
+    return retVal;
+};
+const de_BudgetSchedule = (output, context) => {
+    if (output.fixed != null) {
+        return {
+            fixed: de_FixedBudgetSchedule(output.fixed, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_BudgetSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_BudgetSummary(entry, context);
+    });
+    return retVal;
+};
+const de_BudgetSummary = (output, context) => {
+    return take(output, {
+        approximateDollarLimit: __limitedParseFloat32,
+        budgetId: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        description: __expectString,
+        displayName: __expectString,
+        status: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+        usageTrackingResource: (_) => _json(__expectUnion(_)),
+        usages: (_) => de_ConsumedUsages(_, context),
+    });
+};
+const de_ConsumedUsages = (output, context) => {
+    return take(output, {
+        approximateDollarUsage: __limitedParseFloat32,
+    });
+};
+const de_CustomerManagedFleetConfiguration = (output, context) => {
+    return take(output, {
+        mode: __expectString,
+        storageProfileId: __expectString,
+        workerCapabilities: (_) => de_CustomerManagedWorkerCapabilities(_, context),
+    });
+};
+const de_CustomerManagedWorkerCapabilities = (output, context) => {
+    return take(output, {
+        acceleratorCount: _json,
+        acceleratorTotalMemoryMiB: _json,
+        acceleratorTypes: _json,
+        cpuArchitectureType: __expectString,
+        customAmounts: (_) => de_CustomFleetAmountCapabilities(_, context),
+        customAttributes: _json,
+        memoryMiB: _json,
+        osFamily: __expectString,
+        vCpuCount: _json,
+    });
+};
+const de_CustomFleetAmountCapabilities = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_FleetAmountCapability(entry, context);
+    });
+    return retVal;
+};
+const de_Document = (output, context) => {
+    return output;
+};
+const de_EnvironmentDetailsEntity = (output, context) => {
+    return take(output, {
+        environmentId: __expectString,
+        jobId: __expectString,
+        schemaVersion: __expectString,
+        template: (_) => de_Document(_, context),
+    });
+};
+const de_FarmSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_FarmSummary(entry, context);
+    });
+    return retVal;
+};
+const de_FarmSummary = (output, context) => {
+    return take(output, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        displayName: __expectString,
+        farmId: __expectString,
+        kmsKeyArn: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+};
+const de_FixedBudgetSchedule = (output, context) => {
+    return take(output, {
+        endTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        startTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+    });
+};
+const de_FleetAmountCapabilities = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_FleetAmountCapability(entry, context);
+    });
+    return retVal;
+};
+const de_FleetAmountCapability = (output, context) => {
+    return take(output, {
+        max: __limitedParseFloat32,
+        min: __limitedParseFloat32,
+        name: __expectString,
+    });
+};
+const de_FleetCapabilities = (output, context) => {
+    return take(output, {
+        amounts: (_) => de_FleetAmountCapabilities(_, context),
+        attributes: _json,
+    });
+};
+const de_FleetConfiguration = (output, context) => {
+    if (output.customerManaged != null) {
+        return {
+            customerManaged: de_CustomerManagedFleetConfiguration(output.customerManaged, context),
+        };
+    }
+    if (output.serviceManagedEc2 != null) {
+        return {
+            serviceManagedEc2: de_ServiceManagedEc2FleetConfiguration(output.serviceManagedEc2, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_FleetSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_FleetSummary(entry, context);
+    });
+    return retVal;
+};
+const de_FleetSummary = (output, context) => {
+    return take(output, {
+        autoScalingStatus: __expectString,
+        configuration: (_) => de_FleetConfiguration(__expectUnion(_), context),
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        displayName: __expectString,
+        farmId: __expectString,
+        fleetId: __expectString,
+        maxWorkerCount: __expectInt32,
+        minWorkerCount: __expectInt32,
+        status: __expectString,
+        targetWorkerCount: __expectInt32,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+        workerCount: __expectInt32,
+    });
+};
+const de_JobEntity = (output, context) => {
+    if (output.environmentDetails != null) {
+        return {
+            environmentDetails: de_EnvironmentDetailsEntity(output.environmentDetails, context),
+        };
+    }
+    if (output.jobAttachmentDetails != null) {
+        return {
+            jobAttachmentDetails: _json(output.jobAttachmentDetails),
+        };
+    }
+    if (output.jobDetails != null) {
+        return {
+            jobDetails: _json(output.jobDetails),
+        };
+    }
+    if (output.stepDetails != null) {
+        return {
+            stepDetails: de_StepDetailsEntity(output.stepDetails, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_JobSearchSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_JobSearchSummary(entry, context);
+    });
+    return retVal;
+};
+const de_JobSearchSummary = (output, context) => {
+    return take(output, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        jobId: __expectString,
+        jobParameters: _json,
+        lifecycleStatus: __expectString,
+        lifecycleStatusMessage: __expectString,
+        maxFailedTasksCount: __expectInt32,
+        maxRetriesPerTask: __expectInt32,
+        name: __expectString,
+        priority: __expectInt32,
+        queueId: __expectString,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        targetTaskRunStatus: __expectString,
+        taskRunStatus: __expectString,
+        taskRunStatusCounts: _json,
+    });
+};
+const de_JobSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_JobSummary(entry, context);
+    });
+    return retVal;
+};
+const de_JobSummary = (output, context) => {
+    return take(output, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        jobId: __expectString,
+        lifecycleStatus: __expectString,
+        lifecycleStatusMessage: __expectString,
+        maxFailedTasksCount: __expectInt32,
+        maxRetriesPerTask: __expectInt32,
+        name: __expectString,
+        priority: __expectInt32,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        targetTaskRunStatus: __expectString,
+        taskRunStatus: __expectString,
+        taskRunStatusCounts: _json,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+};
+const de_ListSessionsForWorkerSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_WorkerSessionSummary(entry, context);
+    });
+    return retVal;
+};
+const de_MonitorSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_MonitorSummary(entry, context);
+    });
+    return retVal;
+};
+const de_MonitorSummary = (output, context) => {
+    return take(output, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        displayName: __expectString,
+        identityCenterApplicationArn: __expectString,
+        identityCenterInstanceArn: __expectString,
+        monitorId: __expectString,
+        roleArn: __expectString,
+        subdomain: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+        url: __expectString,
+    });
+};
+const de_QueueFleetAssociationSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_QueueFleetAssociationSummary(entry, context);
+    });
+    return retVal;
+};
+const de_QueueFleetAssociationSummary = (output, context) => {
+    return take(output, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        fleetId: __expectString,
+        queueId: __expectString,
+        status: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+};
+const de_QueueSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_QueueSummary(entry, context);
+    });
+    return retVal;
+};
+const de_QueueSummary = (output, context) => {
+    return take(output, {
+        blockedReason: __expectString,
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        defaultBudgetAction: __expectString,
+        displayName: __expectString,
+        farmId: __expectString,
+        queueId: __expectString,
+        status: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+};
+const de_ResponseBudgetAction = (output, context) => {
+    return take(output, {
+        description: __expectString,
+        thresholdPercentage: __limitedParseFloat32,
+        type: __expectString,
+    });
+};
+const de_ResponseBudgetActionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ResponseBudgetAction(entry, context);
+    });
+    return retVal;
+};
+const de_ServiceManagedEc2FleetConfiguration = (output, context) => {
+    return take(output, {
+        instanceCapabilities: (_) => de_ServiceManagedEc2InstanceCapabilities(_, context),
+        instanceMarketOptions: _json,
+    });
+};
+const de_ServiceManagedEc2InstanceCapabilities = (output, context) => {
+    return take(output, {
+        allowedInstanceTypes: _json,
+        cpuArchitectureType: __expectString,
+        customAmounts: (_) => de_CustomFleetAmountCapabilities(_, context),
+        customAttributes: _json,
+        excludedInstanceTypes: _json,
+        memoryMiB: _json,
+        osFamily: __expectString,
+        rootEbsVolume: _json,
+        vCpuCount: _json,
+    });
+};
+const de_SessionActionSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_SessionActionSummary(entry, context);
+    });
+    return retVal;
+};
+const de_SessionActionSummary = (output, context) => {
+    return take(output, {
+        definition: (_) => _json(__expectUnion(_)),
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        progressPercent: __limitedParseFloat32,
+        sessionActionId: __expectString,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        status: __expectString,
+        workerUpdatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+    });
+};
+const de_SessionSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_SessionSummary(entry, context);
+    });
+    return retVal;
+};
+const de_SessionSummary = (output, context) => {
+    return take(output, {
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        fleetId: __expectString,
+        lifecycleStatus: __expectString,
+        sessionId: __expectString,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        targetLifecycleStatus: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+        workerId: __expectString,
+    });
+};
+const de_Statistics = (output, context) => {
+    return take(output, {
+        aggregationEndTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        aggregationStartTime: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        costInUsd: (_) => de_Stats(_, context),
+        count: __expectInt32,
+        fleetId: __expectString,
+        instanceType: __expectString,
+        jobId: __expectString,
+        jobName: __expectString,
+        licenseProduct: __expectString,
+        queueId: __expectString,
+        runtimeInSeconds: (_) => de_Stats(_, context),
+        usageType: __expectString,
+        userId: __expectString,
+    });
+};
+const de_StatisticsList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Statistics(entry, context);
+    });
+    return retVal;
+};
+const de_Stats = (output, context) => {
+    return take(output, {
+        avg: __limitedParseDouble,
+        max: __limitedParseDouble,
+        min: __limitedParseDouble,
+        sum: __limitedParseDouble,
+    });
+};
+const de_StepAmountCapabilities = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_StepAmountCapability(entry, context);
+    });
+    return retVal;
+};
+const de_StepAmountCapability = (output, context) => {
+    return take(output, {
+        max: __limitedParseDouble,
+        min: __limitedParseDouble,
+        name: __expectString,
+        value: __limitedParseDouble,
+    });
+};
+const de_StepDetailsEntity = (output, context) => {
+    return take(output, {
+        dependencies: _json,
+        jobId: __expectString,
+        schemaVersion: __expectString,
+        stepId: __expectString,
+        template: (_) => de_Document(_, context),
+    });
+};
+const de_StepRequiredCapabilities = (output, context) => {
+    return take(output, {
+        amounts: (_) => de_StepAmountCapabilities(_, context),
+        attributes: _json,
+    });
+};
+const de_StepSearchSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_StepSearchSummary(entry, context);
+    });
+    return retVal;
+};
+const de_StepSearchSummary = (output, context) => {
+    return take(output, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        jobId: __expectString,
+        lifecycleStatus: __expectString,
+        lifecycleStatusMessage: __expectString,
+        name: __expectString,
+        parameterSpace: _json,
+        queueId: __expectString,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        stepId: __expectString,
+        targetTaskRunStatus: __expectString,
+        taskRunStatus: __expectString,
+        taskRunStatusCounts: _json,
+    });
+};
+const de_StepSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_StepSummary(entry, context);
+    });
+    return retVal;
+};
+const de_StepSummary = (output, context) => {
+    return take(output, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        dependencyCounts: _json,
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        lifecycleStatus: __expectString,
+        lifecycleStatusMessage: __expectString,
+        name: __expectString,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        stepId: __expectString,
+        targetTaskRunStatus: __expectString,
+        taskRunStatus: __expectString,
+        taskRunStatusCounts: _json,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+};
+const de_TaskSearchSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_TaskSearchSummary(entry, context);
+    });
+    return retVal;
+};
+const de_TaskSearchSummary = (output, context) => {
+    return take(output, {
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        failureRetryCount: __expectInt32,
+        jobId: __expectString,
+        parameters: _json,
+        queueId: __expectString,
+        runStatus: __expectString,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        stepId: __expectString,
+        targetRunStatus: __expectString,
+        taskId: __expectString,
+    });
+};
+const de_TaskSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_TaskSummary(entry, context);
+    });
+    return retVal;
+};
+const de_TaskSummary = (output, context) => {
+    return take(output, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        failureRetryCount: __expectInt32,
+        latestSessionActionId: __expectString,
+        parameters: _json,
+        runStatus: __expectString,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        targetRunStatus: __expectString,
+        taskId: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+    });
+};
+const de_WorkerSearchSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_WorkerSearchSummary(entry, context);
+    });
+    return retVal;
+};
+const de_WorkerSearchSummary = (output, context) => {
+    return take(output, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        fleetId: __expectString,
+        hostProperties: _json,
+        status: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+        workerId: __expectString,
+    });
+};
+const de_WorkerSessionSummary = (output, context) => {
+    return take(output, {
+        endedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        jobId: __expectString,
+        lifecycleStatus: __expectString,
+        queueId: __expectString,
+        sessionId: __expectString,
+        startedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        targetLifecycleStatus: __expectString,
+    });
+};
+const de_WorkerSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_WorkerSummary(entry, context);
+    });
+    return retVal;
+};
+const de_WorkerSummary = (output, context) => {
+    return take(output, {
+        createdAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        createdBy: __expectString,
+        farmId: __expectString,
+        fleetId: __expectString,
+        hostProperties: _json,
+        log: _json,
+        status: __expectString,
+        updatedAt: (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        updatedBy: __expectString,
+        workerId: __expectString,
+    });
+};
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
+const isSerializableHeaderValue = (value) => value !== undefined &&
+    value !== null &&
+    value !== "" &&
+    (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
+    (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const _aI = "aggregationId";
+const _cT = "clientToken";
+const _dN = "displayName";
+const _fI = "fleetId";
+const _mR = "maxResults";
+const _nT = "nextToken";
+const _pI = "principalId";
+const _qI = "queueId";
+const _rAS = "retryAfterSeconds";
+const _ra = "retry-after";
+const _s = "status";
+const _sI = "sessionId";
+const _tI = "taskId";
+const _tK = "tagKeys";
+const _xact = "x-amz-client-token";