@aws/lsp-codewhisperer 0.0.83 → 0.0.85

package/node_modules/@amzn/codewhisperer-runtime/dist-es/protocols/Aws_restJson1.js

@@ -0,0 +1,2007 @@
+import { CodeWhispererRuntimeServiceException as __BaseException } from "../models/CodeWhispererRuntimeServiceException";
+import { AccessDeniedException, ChatMessage, ConflictException, ImageSource, InternalServerException, ReasoningContent, ResourceNotFoundException, ServiceQuotaExceededException, TelemetryEvent, ThrottlingException, Tool, ToolResultContentBlock, UpdateUsageLimitQuotaExceededException, ValidationException, } from "../models/models_0";
+import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
+import { requestBuilder as rb } from "@smithy/core";
+import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, parseEpochTimestamp as __parseEpochTimestamp, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, serializeFloat as __serializeFloat, _json, collectBody, map, take, withBaseException, } from "@smithy/smithy-client";
+import { v4 as generateIdempotencyToken } from "uuid";
+export const se_CreateArtifactUploadUrlCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/createartifactuploadurl");
+    let body;
+    body = JSON.stringify(take(input, {
+        'artifactType': [],
+        'contentChecksum': [],
+        'contentChecksumType': [],
+        'contentLength': [],
+        'contentMd5': [],
+        'profileArn': [],
+        'uploadContext': _ => _json(_),
+        'uploadId': [],
+        'uploadIntent': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_CreateSubscriptionTokenCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/CreateSubscriptionToken");
+    let body;
+    body = JSON.stringify(take(input, {
+        'clientToken': [true, _ => _ ?? generateIdempotencyToken()],
+        'provider': [],
+        'statusOnly': [],
+        'subscriptionType': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_CreateTaskAssistConversationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/createTaskAssistConversation");
+    let body;
+    body = JSON.stringify(take(input, {
+        'profileArn': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_CreateUploadUrlCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/createuploadurl");
+    let body;
+    body = JSON.stringify(take(input, {
+        'artifactType': [],
+        'contentChecksum': [],
+        'contentChecksumType': [],
+        'contentLength': [],
+        'contentMd5': [],
+        'profileArn': [],
+        'uploadContext': _ => _json(_),
+        'uploadId': [],
+        'uploadIntent': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_CreateUserMemoryEntryCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/CreateUserMemoryEntry");
+    let body;
+    body = JSON.stringify(take(input, {
+        'clientToken': [true, _ => _ ?? generateIdempotencyToken()],
+        'memoryEntryString': [],
+        'origin': [],
+        'profileArn': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_CreateWorkspaceCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/CreateWorkspace");
+    let body;
+    body = JSON.stringify(take(input, {
+        'profileArn': [],
+        'workspaceRoot': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_DeleteTaskAssistConversationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/deleteTaskAssistConversation");
+    let body;
+    body = JSON.stringify(take(input, {
+        'conversationId': [],
+        'profileArn': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_DeleteUserMemoryEntryCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/DeleteUserMemoryEntry/{id}");
+    b.p('id', () => input.id, '{id}', false);
+    let body;
+    body = JSON.stringify(take(input, {
+        'profileArn': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_DeleteWorkspaceCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/DeleteWorkspace");
+    let body;
+    body = JSON.stringify(take(input, {
+        'profileArn': [],
+        'workspaceId': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_GenerateCompletionsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/generatecompletions");
+    let body;
+    body = JSON.stringify(take(input, {
+        'customizationArn': [],
+        'editorState': _ => _json(_),
+        'fileContext': _ => _json(_),
+        'maxResults': [],
+        'modelId': [],
+        'nextToken': [],
+        'optOutPreference': [],
+        'predictionTypes': _ => _json(_),
+        'profileArn': [],
+        'referenceTrackerConfiguration': _ => _json(_),
+        'supplementalContexts': _ => _json(_),
+        'userContext': _ => _json(_),
+        'workspaceId': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_GetCodeAnalysisCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/getcodeanalysis/{jobId+}");
+    b.p('jobId', () => input.jobId, '{jobId+}', true);
+    const query = map({
+        [_pA]: [, input[_pA]],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
+export const se_GetCodeFixJobCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/getcodefixjob/{jobId}");
+    b.p('jobId', () => input.jobId, '{jobId}', false);
+    const query = map({
+        [_pA]: [, input[_pA]],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
+export const se_GetProfileCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/GetProfile");
+    let body;
+    body = JSON.stringify(take(input, {
+        'profileArn': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_GetRetrievalsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/GetRetrievals");
+    let body;
+    body = JSON.stringify(take(input, {
+        'customizationArn': [],
+        'languageName': [],
+        'maxResults': [],
+        'query': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_GetTaskAssistCodeGenerationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/getTaskAssistCodeGeneration/{conversationId}/{codeGenerationId}");
+    b.p('conversationId', () => input.conversationId, '{conversationId}', false);
+    b.p('codeGenerationId', () => input.codeGenerationId, '{codeGenerationId}', false);
+    const query = map({
+        [_pA]: [, input[_pA]],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
+export const se_GetTestGenerationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/getTestGeneration/{testGenerationJobGroupName}/{testGenerationJobId}");
+    b.p('testGenerationJobGroupName', () => input.testGenerationJobGroupName, '{testGenerationJobGroupName}', false);
+    b.p('testGenerationJobId', () => input.testGenerationJobId, '{testGenerationJobId}', false);
+    const query = map({
+        [_pA]: [, input[_pA]],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
+export const se_GetTransformationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/getTransformation/{transformationJobId+}");
+    b.p('transformationJobId', () => input.transformationJobId, '{transformationJobId+}', true);
+    const query = map({
+        [_pA]: [, input[_pA]],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
+export const se_GetTransformationPlanCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/getTransformationPlan/{transformationJobId+}");
+    b.p('transformationJobId', () => input.transformationJobId, '{transformationJobId+}', true);
+    const query = map({
+        [_pA]: [, input[_pA]],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
+export const se_GetUsageLimitsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/getUsageLimits");
+    const query = map({
+        [_pA]: [, input[_pA]],
+        [_o]: [, input[_o]],
+        [_rT]: [, input[_rT]],
+        [_iER]: [() => input.isEmailRequired !== void 0, () => (input[_iER].toString())],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
+export const se_ListAvailableCustomizationsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/ListAvailableCustomizations");
+    let body;
+    body = JSON.stringify(take(input, {
+        'maxResults': [],
+        'nextToken': [],
+        'profileArn': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_ListAvailableModelsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/ListAvailableModels");
+    const query = map({
+        [_o]: [, __expectNonNull(input[_o], `origin`)],
+        [_mR]: [() => input.maxResults !== void 0, () => (input[_mR].toString())],
+        [_nT]: [, input[_nT]],
+        [_pA]: [, input[_pA]],
+        [_mP]: [, input[_mP]],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
+export const se_ListAvailableProfilesCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/ListAvailableProfiles");
+    let body;
+    body = JSON.stringify(take(input, {
+        'maxResults': [],
+        'nextToken': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_ListAvailableSubscriptionsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/listAvailableSubscriptions");
+    let body;
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_ListCodeAnalysisFindingsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/listcodeanalysisfindings/{jobId}");
+    b.p('jobId', () => input.jobId, '{jobId}', false);
+    const query = map({
+        [_nT]: [, input[_nT]],
+        [_s]: [, __expectNonNull(input[_cAFS], `codeAnalysisFindingsSchema`)],
+        [_pA]: [, input[_pA]],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
+export const se_ListEventsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/events");
+    let body;
+    body = JSON.stringify(take(input, {
+        'conversationId': [],
+        'maxResults': [],
+        'nextToken': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_ListFeatureEvaluationsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/ListFeatureEvaluations");
+    let body;
+    body = JSON.stringify(take(input, {
+        'profileArn': [],
+        'userContext': _ => _json(_),
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_ListUserMemoryEntriesCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/ListUserMemoryEntries");
+    let body;
+    body = JSON.stringify(take(input, {
+        'maxResults': [],
+        'nextToken': [],
+        'profileArn': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_ListWorkspaceMetadataCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/ListWorkspaceMetadata");
+    let body;
+    body = JSON.stringify(take(input, {
+        'maxResults': [],
+        'nextToken': [],
+        'profileArn': [],
+        'workspaceRoot': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_PushTelemetryEventCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/PushTelemetryEvent");
+    let body;
+    body = JSON.stringify(take(input, {
+        'clientToken': [true, _ => _ ?? generateIdempotencyToken()],
+        'event': _ => se_Document(_, context),
+        'eventType': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_ResumeTransformationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/resumeTransformation/{transformationJobId+}");
+    b.p('transformationJobId', () => input.transformationJobId, '{transformationJobId+}', true);
+    let body;
+    body = JSON.stringify(take(input, {
+        'profileArn': [],
+        'userActionStatus': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_SendTelemetryEventCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/SendTelemetryEvent");
+    let body;
+    body = JSON.stringify(take(input, {
+        'clientToken': [true, _ => _ ?? generateIdempotencyToken()],
+        'modelId': [],
+        'optOutPreference': [],
+        'profileArn': [],
+        'telemetryEvent': _ => se_TelemetryEvent(_, context),
+        'userContext': _ => _json(_),
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_SetUserPreferenceCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/setUserPreference");
+    let body;
+    body = JSON.stringify(take(input, {
+        'overageConfiguration': _ => _json(_),
+        'profileArn': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_StartCodeAnalysisCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/startcodeanalysis");
+    let body;
+    body = JSON.stringify(take(input, {
+        'artifacts': _ => _json(_),
+        'clientToken': [true, _ => _ ?? generateIdempotencyToken()],
+        'clientType': [],
+        'codeDiffMetadata': _ => _json(_),
+        'codeScanName': [],
+        'languageModelId': [],
+        'profileArn': [],
+        'programmingLanguage': _ => _json(_),
+        'scope': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_StartCodeFixJobCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/startcodefixjob");
+    let body;
+    body = JSON.stringify(take(input, {
+        'codeFixName': [],
+        'description': [],
+        'profileArn': [],
+        'referenceTrackerConfiguration': _ => _json(_),
+        'ruleId': [],
+        'snippetRange': _ => _json(_),
+        'uploadId': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_StartTaskAssistCodeGenerationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/startTaskAssistCodeGeneration");
+    let body;
+    body = JSON.stringify(take(input, {
+        'codeGenerationId': [],
+        'conversationState': _ => se_ConversationState(_, context),
+        'currentCodeGenerationId': [],
+        'intent': [],
+        'intentContext': _ => _json(_),
+        'profileArn': [],
+        'taskAssistPlan': _ => _json(_),
+        'workspaceState': _ => _json(_),
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_StartTestGenerationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/startTestGeneration");
+    let body;
+    body = JSON.stringify(take(input, {
+        'clientToken': [true, _ => _ ?? generateIdempotencyToken()],
+        'profileArn': [],
+        'referenceTrackerConfiguration': _ => _json(_),
+        'targetCodeList': _ => _json(_),
+        'testGenerationJobGroupName': [],
+        'uploadId': [],
+        'userInput': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_StartTransformationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/startTransformation");
+    let body;
+    body = JSON.stringify(take(input, {
+        'profileArn': [],
+        'transformationSpec': _ => _json(_),
+        'workspaceState': _ => _json(_),
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_StopTransformationCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/stopTransformation/{transformationJobId+}");
+    b.p('transformationJobId', () => input.transformationJobId, '{transformationJobId+}', true);
+    const query = map({
+        [_pA]: [, input[_pA]],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
+export const se_UpdateUsageLimitsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    b.bp("/updateUsageLimits");
+    let body;
+    body = JSON.stringify(take(input, {
+        'accountId': [],
+        'accountlessUserId': [],
+        'directoryId': [],
+        'featureType': [],
+        'justification': [],
+        'permanentOverride': [],
+        'requestedLimit': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const de_CreateArtifactUploadUrlCommand = 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, {
+        'kmsKeyArn': __expectString,
+        'requestHeaders': _json,
+        'uploadId': __expectString,
+        'uploadUrl': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateSubscriptionTokenCommand = 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, {
+        'encodedVerificationUrl': __expectString,
+        'status': __expectString,
+        'token': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateTaskAssistConversationCommand = 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, {
+        'conversationId': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateUploadUrlCommand = 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, {
+        'kmsKeyArn': __expectString,
+        'requestHeaders': _json,
+        'uploadId': __expectString,
+        'uploadUrl': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateUserMemoryEntryCommand = 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, {
+        'memoryEntry': _ => de_MemoryEntry(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_CreateWorkspaceCommand = 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, {
+        'workspace': _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_DeleteTaskAssistConversationCommand = 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, {
+        'conversationId': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_DeleteUserMemoryEntryCommand = 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_DeleteWorkspaceCommand = 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_GenerateCompletionsCommand = 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, {
+        'completions': _json,
+        'modelId': __expectString,
+        'nextToken': __expectString,
+        'predictions': _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetCodeAnalysisCommand = 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, {
+        'errorMessage': __expectString,
+        'status': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetCodeFixJobCommand = 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, {
+        'jobStatus': __expectString,
+        'suggestedFix': _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetProfileCommand = 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, {
+        'profile': _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetRetrievalsCommand = 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, {
+        'retrievalMap': _ => de_RetrievalMap(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetTaskAssistCodeGenerationCommand = 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, {
+        'codeGenerationRemainingIterationCount': __expectInt32,
+        'codeGenerationStatus': _json,
+        'codeGenerationStatusDetail': __expectString,
+        'codeGenerationTotalIterationCount': __expectInt32,
+        'conversationId': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetTestGenerationCommand = 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, {
+        'testGenerationJob': _ => de_TestGenerationJob(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetTransformationCommand = 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, {
+        'transformationJob': _ => de_TransformationJob(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetTransformationPlanCommand = 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, {
+        'transformationPlan': _ => de_TransformationPlan(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetUsageLimitsCommand = 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, {
+        'daysUntilReset': __expectInt32,
+        'limits': _ => de_UsageLimits(_, context),
+        'nextDateReset': _ => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'overageConfiguration': _json,
+        'subscriptionInfo': _json,
+        'usageBreakdown': _ => de_UsageBreakdown(_, context),
+        'usageBreakdownList': _ => de_UsageBreakdownList(_, context),
+        'userInfo': _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListAvailableCustomizationsCommand = 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, {
+        'customizations': _json,
+        'nextToken': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListAvailableModelsCommand = 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, {
+        'defaultModel': _json,
+        'models': _json,
+        'nextToken': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListAvailableProfilesCommand = 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,
+        'profiles': _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListAvailableSubscriptionsCommand = 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, {
+        'disclaimer': _json,
+        'subscriptionPlans': _ => de_SubscriptionPlanList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListCodeAnalysisFindingsCommand = 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, {
+        'codeAnalysisFindings': __expectString,
+        'nextToken': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListEventsCommand = 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, {
+        'conversationId': __expectString,
+        'events': _ => de_EventList(_, context),
+        'nextToken': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListFeatureEvaluationsCommand = 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, {
+        'featureEvaluations': _ => de_FeatureEvaluationsList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListUserMemoryEntriesCommand = 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, {
+        'memoryEntries': _ => de_MemoryEntryList(_, context),
+        'nextToken': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListWorkspaceMetadataCommand = 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,
+        'workspaces': _json,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_PushTelemetryEventCommand = 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_ResumeTransformationCommand = 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, {
+        'transformationStatus': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_SendTelemetryEventCommand = 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_SetUserPreferenceCommand = 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_StartCodeAnalysisCommand = 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, {
+        'errorMessage': __expectString,
+        'jobId': __expectString,
+        'status': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_StartCodeFixJobCommand = 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, {
+        'jobId': __expectString,
+        'status': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_StartTaskAssistCodeGenerationCommand = 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, {
+        'codeGenerationId': __expectString,
+        'conversationId': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_StartTestGenerationCommand = 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, {
+        'testGenerationJob': _ => de_TestGenerationJob(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_StartTransformationCommand = 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, {
+        'transformationJobId': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_StopTransformationCommand = 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, {
+        'transformationStatus': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_UpdateUsageLimitsCommand = 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, {
+        'approvedLimit': __expectLong,
+        'remainingRequestsThisMonth': __expectInt32,
+        'status': __expectString,
+    });
+    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.amazon.aws.codewhisperer#AccessDeniedException":
+            throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazon.aws.codewhisperer#InternalServerException":
+            throw await de_InternalServerExceptionRes(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazon.aws.codewhisperer#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazon.aws.codewhisperer#ValidationException":
+            throw await de_ValidationExceptionRes(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazon.aws.codewhisperer#ConflictException":
+            throw await de_ConflictExceptionRes(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazon.aws.codewhisperer#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazon.aws.codewhisperer#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+        case "UpdateUsageLimitQuotaExceededException":
+        case "com.amazon.aws.codewhisperer.runtime#UpdateUsageLimitQuotaExceededException":
+            throw await de_UpdateUsageLimitQuotaExceededExceptionRes(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, {
+        'message': __expectString,
+        'reason': __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, {
+        'message': __expectString,
+        'reason': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_InternalServerExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+        'reason': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InternalServerException({
+        $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, {
+        'message': __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, {
+        'message': __expectString,
+        'reason': __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({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+        'reason': __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, {
+        'message': __expectString,
+        'reason': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ValidationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_UpdateUsageLimitQuotaExceededExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new UpdateUsageLimitQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const se_AssistantResponseMessage = (input, context) => {
+    return take(input, {
+        'cachePoint': _json,
+        'content': [],
+        'followupPrompt': _json,
+        'messageId': [],
+        'reasoningContent': _ => se_ReasoningContent(_, context),
+        'references': _json,
+        'supplementaryWebLinks': _json,
+        'toolUses': _ => se_ToolUses(_, context),
+    });
+};
+const se_ChatAddMessageEvent = (input, context) => {
+    return take(input, {
+        'activeEditorTotalCharacters': [],
+        'conversationId': [],
+        'customizationArn': [],
+        'fullResponselatency': __serializeFloat,
+        'hasCodeSnippet': [],
+        'hasProjectLevelContext': [],
+        'messageId': [],
+        'numberOfCodeBlocks': [],
+        'programmingLanguage': _json,
+        'requestLength': [],
+        'responseLength': [],
+        'result': [],
+        'timeBetweenChunks': _ => se_timeBetweenChunks(_, context),
+        'timeToFirstChunkMilliseconds': __serializeFloat,
+        'userIntent': [],
+    });
+};
+const se_ChatHistory = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ChatMessage(entry, context);
+    });
+};
+const se_ChatMessage = (input, context) => {
+    return ChatMessage.visit(input, {
+        assistantResponseMessage: value => ({ "assistantResponseMessage": se_AssistantResponseMessage(value, context) }),
+        userInputMessage: value => ({ "userInputMessage": se_UserInputMessage(value, context) }),
+        _: (name, value) => ({ name: value })
+    });
+};
+const se_ChatUserModificationEvent = (input, context) => {
+    return take(input, {
+        'conversationId': [],
+        'customizationArn': [],
+        'hasProjectLevelContext': [],
+        'messageId': [],
+        'modificationPercentage': __serializeFloat,
+        'programmingLanguage': _json,
+    });
+};
+const se_CodeCoverageEvent = (input, context) => {
+    return take(input, {
+        'acceptedCharacterCount': [],
+        'addedCharacterCount': [],
+        'customizationArn': [],
+        'programmingLanguage': _json,
+        'timestamp': _ => (_.getTime() / 1000),
+        'totalCharacterCount': [],
+        'totalNewCodeCharacterCount': [],
+        'totalNewCodeLineCount': [],
+        'unmodifiedAcceptedCharacterCount': [],
+        'userWrittenCodeCharacterCount': [],
+        'userWrittenCodeLineCount': [],
+    });
+};
+const se_CodeScanEvent = (input, context) => {
+    return take(input, {
+        'codeAnalysisScope': [],
+        'codeScanJobId': [],
+        'programmingLanguage': _json,
+        'timestamp': _ => (_.getTime() / 1000),
+    });
+};
+const se_CodeScanFailedEvent = (input, context) => {
+    return take(input, {
+        'codeAnalysisScope': [],
+        'codeScanJobId': [],
+        'programmingLanguage': _json,
+        'timestamp': _ => (_.getTime() / 1000),
+    });
+};
+const se_CodeScanRemediationsEvent = (input, context) => {
+    return take(input, {
+        'CodeScanRemediationsEventType': [],
+        'component': [],
+        'detectorId': [],
+        'findingId': [],
+        'includesFix': [],
+        'programmingLanguage': _json,
+        'reason': [],
+        'result': [],
+        'ruleId': [],
+        'timestamp': _ => (_.getTime() / 1000),
+    });
+};
+const se_CodeScanSucceededEvent = (input, context) => {
+    return take(input, {
+        'codeAnalysisScope': [],
+        'codeScanJobId': [],
+        'numberOfFindings': [],
+        'programmingLanguage': _json,
+        'timestamp': _ => (_.getTime() / 1000),
+    });
+};
+const se_ConversationState = (input, context) => {
+    return take(input, {
+        'agentContinuationId': [],
+        'agentTaskType': [],
+        'chatTriggerType': [],
+        'conversationId': [],
+        'currentMessage': _ => se_ChatMessage(_, context),
+        'customizationArn': [],
+        'history': _ => se_ChatHistory(_, context),
+        'workspaceId': [],
+    });
+};
+const se_ImageBlock = (input, context) => {
+    return take(input, {
+        'format': [],
+        'source': _ => se_ImageSource(_, context),
+    });
+};
+const se_ImageBlocks = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ImageBlock(entry, context);
+    });
+};
+const se_ImageSource = (input, context) => {
+    return ImageSource.visit(input, {
+        bytes: value => ({ "bytes": context.base64Encoder(value) }),
+        _: (name, value) => ({ name: value })
+    });
+};
+const se_InlineChatEvent = (input, context) => {
+    return take(input, {
+        'codeIntent': [],
+        'inputLength': [],
+        'numSelectedLines': [],
+        'numSuggestionAddChars': [],
+        'numSuggestionAddLines': [],
+        'numSuggestionDelChars': [],
+        'numSuggestionDelLines': [],
+        'programmingLanguage': _json,
+        'requestId': [],
+        'responseEndLatency': __serializeFloat,
+        'responseStartLatency': __serializeFloat,
+        'timestamp': _ => (_.getTime() / 1000),
+        'userDecision': [],
+    });
+};
+const se_MetricData = (input, context) => {
+    return take(input, {
+        'dimensions': _json,
+        'metricName': [],
+        'metricValue': __serializeFloat,
+        'product': [],
+        'timestamp': _ => (_.getTime() / 1000),
+    });
+};
+const se_ReasoningContent = (input, context) => {
+    return ReasoningContent.visit(input, {
+        reasoningText: value => ({ "reasoningText": _json(value) }),
+        redactedContent: value => ({ "redactedContent": context.base64Encoder(value) }),
+        _: (name, value) => ({ name: value })
+    });
+};
+const se_SensitiveDocument = (input, context) => {
+    return input;
+};
+const se_TelemetryEvent = (input, context) => {
+    return TelemetryEvent.visit(input, {
+        chatAddMessageEvent: value => ({ "chatAddMessageEvent": se_ChatAddMessageEvent(value, context) }),
+        chatInteractWithMessageEvent: value => ({ "chatInteractWithMessageEvent": _json(value) }),
+        chatUserModificationEvent: value => ({ "chatUserModificationEvent": se_ChatUserModificationEvent(value, context) }),
+        codeCoverageEvent: value => ({ "codeCoverageEvent": se_CodeCoverageEvent(value, context) }),
+        codeFixAcceptanceEvent: value => ({ "codeFixAcceptanceEvent": _json(value) }),
+        codeFixGenerationEvent: value => ({ "codeFixGenerationEvent": _json(value) }),
+        codeScanEvent: value => ({ "codeScanEvent": se_CodeScanEvent(value, context) }),
+        codeScanFailedEvent: value => ({ "codeScanFailedEvent": se_CodeScanFailedEvent(value, context) }),
+        codeScanRemediationsEvent: value => ({ "codeScanRemediationsEvent": se_CodeScanRemediationsEvent(value, context) }),
+        codeScanSucceededEvent: value => ({ "codeScanSucceededEvent": se_CodeScanSucceededEvent(value, context) }),
+        docGenerationEvent: value => ({ "docGenerationEvent": _json(value) }),
+        docV2AcceptanceEvent: value => ({ "docV2AcceptanceEvent": _json(value) }),
+        docV2GenerationEvent: value => ({ "docV2GenerationEvent": _json(value) }),
+        featureDevCodeAcceptanceEvent: value => ({ "featureDevCodeAcceptanceEvent": _json(value) }),
+        featureDevCodeGenerationEvent: value => ({ "featureDevCodeGenerationEvent": _json(value) }),
+        featureDevEvent: value => ({ "featureDevEvent": _json(value) }),
+        inlineChatEvent: value => ({ "inlineChatEvent": se_InlineChatEvent(value, context) }),
+        metricData: value => ({ "metricData": se_MetricData(value, context) }),
+        terminalUserInteractionEvent: value => ({ "terminalUserInteractionEvent": _json(value) }),
+        testGenerationEvent: value => ({ "testGenerationEvent": se_TestGenerationEvent(value, context) }),
+        transformEvent: value => ({ "transformEvent": se_TransformEvent(value, context) }),
+        userModificationEvent: value => ({ "userModificationEvent": se_UserModificationEvent(value, context) }),
+        userTriggerDecisionEvent: value => ({ "userTriggerDecisionEvent": se_UserTriggerDecisionEvent(value, context) }),
+        _: (name, value) => ({ name: value })
+    });
+};
+const se_TestGenerationEvent = (input, context) => {
+    return take(input, {
+        'charsOfCodeAccepted': [],
+        'charsOfCodeGenerated': [],
+        'groupName': [],
+        'ideCategory': [],
+        'jobId': [],
+        'linesOfCodeAccepted': [],
+        'linesOfCodeGenerated': [],
+        'numberOfUnitTestCasesAccepted': [],
+        'numberOfUnitTestCasesGenerated': [],
+        'programmingLanguage': _json,
+        'timestamp': _ => (_.getTime() / 1000),
+    });
+};
+const se_timeBetweenChunks = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return __serializeFloat(entry);
+    });
+};
+const se_Tool = (input, context) => {
+    return Tool.visit(input, {
+        cachePoint: value => ({ "cachePoint": _json(value) }),
+        toolSpecification: value => ({ "toolSpecification": se_ToolSpecification(value, context) }),
+        _: (name, value) => ({ name: value })
+    });
+};
+const se_ToolInputSchema = (input, context) => {
+    return take(input, {
+        'json': _ => se_SensitiveDocument(_, context),
+    });
+};
+const se_ToolResult = (input, context) => {
+    return take(input, {
+        'content': _ => se_ToolResultContent(_, context),
+        'status': [],
+        'toolUseId': [],
+    });
+};
+const se_ToolResultContent = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ToolResultContentBlock(entry, context);
+    });
+};
+const se_ToolResultContentBlock = (input, context) => {
+    return ToolResultContentBlock.visit(input, {
+        json: value => ({ "json": se_SensitiveDocument(value, context) }),
+        text: value => ({ "text": value }),
+        _: (name, value) => ({ name: value })
+    });
+};
+const se_ToolResults = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ToolResult(entry, context);
+    });
+};
+const se_Tools = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_Tool(entry, context);
+    });
+};
+const se_ToolSpecification = (input, context) => {
+    return take(input, {
+        'description': [],
+        'inputSchema': _ => se_ToolInputSchema(_, context),
+        'name': [],
+    });
+};
+const se_ToolUse = (input, context) => {
+    return take(input, {
+        'input': _ => se_SensitiveDocument(_, context),
+        'name': [],
+        'toolUseId': [],
+    });
+};
+const se_ToolUses = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ToolUse(entry, context);
+    });
+};
+const se_TransformEvent = (input, context) => {
+    return take(input, {
+        'charsOfCodeChanged': [],
+        'ideCategory': [],
+        'jobId': [],
+        'linesOfCodeChanged': [],
+        'linesOfCodeSubmitted': [],
+        'programmingLanguage': _json,
+        'timestamp': _ => (_.getTime() / 1000),
+    });
+};
+const se_UserInputMessage = (input, context) => {
+    return take(input, {
+        'cachePoint': _json,
+        'clientCacheConfig': _json,
+        'content': [],
+        'images': _ => se_ImageBlocks(_, context),
+        'modelId': [],
+        'origin': [],
+        'userInputMessageContext': _ => se_UserInputMessageContext(_, context),
+        'userIntent': [],
+    });
+};
+const se_UserInputMessageContext = (input, context) => {
+    return take(input, {
+        'additionalContext': _json,
+        'appStudioContext': _json,
+        'consoleState': _json,
+        'diagnostic': _json,
+        'editorState': _json,
+        'envState': _json,
+        'gitState': _json,
+        'shellState': _json,
+        'toolResults': _ => se_ToolResults(_, context),
+        'tools': _ => se_Tools(_, context),
+        'userSettings': _json,
+    });
+};
+const se_UserModificationEvent = (input, context) => {
+    return take(input, {
+        'acceptedCharacterCount': [],
+        'addedCharacterCount': [],
+        'customizationArn': [],
+        'modificationPercentage': __serializeFloat,
+        'programmingLanguage': _json,
+        'requestId': [],
+        'sessionId': [],
+        'timestamp': _ => (_.getTime() / 1000),
+        'unmodifiedAcceptedCharacterCount': [],
+        'unmodifiedAddedCharacterCount': [],
+    });
+};
+const se_UserTriggerDecisionEvent = (input, context) => {
+    return take(input, {
+        'acceptedCharacterCount': [],
+        'addedCharacterCount': [],
+        'addedIdeDiagnostics': _json,
+        'completionType': [],
+        'customizationArn': [],
+        'deletedCharacterCount': [],
+        'generatedLine': [],
+        'numberOfRecommendations': [],
+        'perceivedLatencyMilliseconds': __serializeFloat,
+        'programmingLanguage': _json,
+        'recommendationLatencyMilliseconds': __serializeFloat,
+        'removedIdeDiagnostics': _json,
+        'requestId': [],
+        'sessionId': [],
+        'streakLength': [],
+        'suggestionReferenceCount': [],
+        'suggestionState': [],
+        'suggestionType': [],
+        'timestamp': _ => (_.getTime() / 1000),
+        'triggerToResponseLatencyMilliseconds': __serializeFloat,
+    });
+};
+const se_Document = (input, context) => {
+    return input;
+};
+const de_FeatureEvaluation = (output, context) => {
+    return take(output, {
+        'feature': __expectString,
+        'value': (_) => de_FeatureValue(__expectUnion(_), context),
+        'variation': __expectString,
+    });
+};
+const de_FeatureEvaluationsList = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_FeatureEvaluation(entry, context);
+    });
+    return retVal;
+};
+const de_FeatureValue = (output, context) => {
+    if (__expectBoolean(output.boolValue) !== undefined) {
+        return { boolValue: __expectBoolean(output.boolValue) };
+    }
+    if (__limitedParseDouble(output.doubleValue) !== undefined) {
+        return { doubleValue: __limitedParseDouble(output.doubleValue) };
+    }
+    if (__expectLong(output.longValue) !== undefined) {
+        return { longValue: __expectLong(output.longValue) };
+    }
+    if (__expectString(output.stringValue) !== undefined) {
+        return { stringValue: __expectString(output.stringValue) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_ProgressUpdates = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_TransformationProgressUpdate(entry, context);
+    });
+    return retVal;
+};
+const de_TestGenerationJob = (output, context) => {
+    return take(output, {
+        'creationTime': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'jobPlan': __expectString,
+        'jobStatusReason': __expectString,
+        'jobSummary': __expectString,
+        'packageInfoList': _json,
+        'progressRate': __expectInt32,
+        'shortAnswer': __expectString,
+        'status': __expectString,
+        'testGenerationJobGroupName': __expectString,
+        'testGenerationJobId': __expectString,
+    });
+};
+const de_TransformationJob = (output, context) => {
+    return take(output, {
+        'creationTime': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'endExecutionTime': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'jobId': __expectString,
+        'reason': __expectString,
+        'startExecutionTime': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'status': __expectString,
+        'transformationSpec': _json,
+    });
+};
+const de_TransformationPlan = (output, context) => {
+    return take(output, {
+        'transformationSteps': (_) => de_TransformationSteps(_, context),
+    });
+};
+const de_TransformationProgressUpdate = (output, context) => {
+    return take(output, {
+        'description': __expectString,
+        'downloadArtifacts': _json,
+        'endTime': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'name': __expectString,
+        'startTime': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'status': __expectString,
+    });
+};
+const de_TransformationStep = (output, context) => {
+    return take(output, {
+        'description': __expectString,
+        'endTime': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'id': __expectString,
+        'name': __expectString,
+        'progressUpdates': (_) => de_ProgressUpdates(_, context),
+        'startTime': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'status': __expectString,
+    });
+};
+const de_TransformationSteps = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_TransformationStep(entry, context);
+    });
+    return retVal;
+};
+const de_UsageLimitList = (output, context) => {
+    return take(output, {
+        'currentUsage': __expectLong,
+        'percentUsed': __limitedParseDouble,
+        'totalUsageLimit': __expectLong,
+        'type': __expectString,
+    });
+};
+const de_UsageLimits = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_UsageLimitList(entry, context);
+    });
+    return retVal;
+};
+const de_Event = (output, context) => {
+    return take(output, {
+        'eventBlob': context.base64Decoder,
+        'eventId': __expectString,
+        'eventTimestamp': (_) => __expectNonNull(__parseRfc3339DateTimeWithOffset(_)),
+        'eventType': __expectString,
+        'generationId': __expectString,
+    });
+};
+const de_EventList = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_Event(entry, context);
+    });
+    return retVal;
+};
+const de_FreeTrialInfo = (output, context) => {
+    return take(output, {
+        'currentUsage': __expectInt32,
+        'currentUsageWithPrecision': __limitedParseDouble,
+        'freeTrialExpiry': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'freeTrialStatus': __expectString,
+        'usageLimit': __expectInt32,
+        'usageLimitWithPrecision': __limitedParseDouble,
+    });
+};
+const de_PricingInfo = (output, context) => {
+    return take(output, {
+        'amount': __limitedParseDouble,
+        'currency': __expectString,
+    });
+};
+const de_Retrieval = (output, context) => {
+    return take(output, {
+        'content': __expectString,
+        'filepath': __expectString,
+        'repository': __expectString,
+        'score': __limitedParseDouble,
+        'uri': __expectString,
+    });
+};
+const de_RetrievalMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = de_RetrievalsList(value, context);
+        return acc;
+    }, {});
+};
+const de_RetrievalsList = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_Retrieval(entry, context);
+    });
+    return retVal;
+};
+const de_SubscriptionPlan = (output, context) => {
+    return take(output, {
+        'description': _json,
+        'name': __expectString,
+        'pricing': (_) => de_PricingInfo(_, context),
+        'qSubscriptionType': __expectString,
+    });
+};
+const de_SubscriptionPlanList = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_SubscriptionPlan(entry, context);
+    });
+    return retVal;
+};
+const de_UsageBreakdown = (output, context) => {
+    return take(output, {
+        'currency': __expectString,
+        'currentOverages': __expectInt32,
+        'currentOveragesWithPrecision': __limitedParseDouble,
+        'currentUsage': __expectInt32,
+        'currentUsageWithPrecision': __limitedParseDouble,
+        'displayName': __expectString,
+        'displayNamePlural': __expectString,
+        'freeTrialInfo': (_) => de_FreeTrialInfo(_, context),
+        'nextDateReset': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'overageCap': __expectInt32,
+        'overageCapWithPrecision': __limitedParseDouble,
+        'overageCharges': __limitedParseDouble,
+        'overageRate': __limitedParseDouble,
+        'resourceType': __expectString,
+        'unit': __expectString,
+        'usageLimit': __expectInt32,
+        'usageLimitWithPrecision': __limitedParseDouble,
+    });
+};
+const de_UsageBreakdownList = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_UsageBreakdown(entry, context);
+    });
+    return retVal;
+};
+const de_MemoryEntry = (output, context) => {
+    return take(output, {
+        'id': __expectString,
+        'memoryEntryString': __expectString,
+        'metadata': (_) => de_MemoryEntryMetadata(_, context),
+    });
+};
+const de_MemoryEntryList = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_MemoryEntry(entry, context);
+    });
+    return retVal;
+};
+const de_MemoryEntryMetadata = (output, context) => {
+    return take(output, {
+        'attributes': _json,
+        'createdAt': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'memoryStatus': __expectString,
+        'origin': __expectString,
+        'updatedAt': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+};
+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 _cAFS = "codeAnalysisFindingsSchema";
+const _iER = "isEmailRequired";
+const _mP = "modelProvider";
+const _mR = "maxResults";
+const _nT = "nextToken";
+const _o = "origin";
+const _pA = "profileArn";
+const _rT = "resourceType";
+const _s = "schema";