@anweather/game-plugin-ssdk 1.2.0

package/dist-es/src/protocols/Aws_restJson1.js

@@ -0,0 +1,1041 @@
+import { parseJsonBody as parseBody, } from "@aws-sdk/core";
+import { NotAcceptableException as __NotAcceptableException, UnsupportedMediaTypeException as __UnsupportedMediaTypeException, acceptMatches as __acceptMatches, } from "@aws-smithy/server-common";
+import { HttpResponse as __HttpResponse, } from "@smithy/protocol-http";
+import { expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, parseRfc3339DateTime as __parseRfc3339DateTime, collectBody, isSerializableHeaderValue, map, take, } from "@smithy/smithy-client";
+import { calculateBodyLength } from "@smithy/util-body-length-node";
+export const deserializeApplyMoveRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'move': _ => de_Move(_, context),
+        'pluginState': _ => de_Document(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeApplySaveFileEditRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'edit': _ => de_Document(_, context),
+        'profile': _ => de_Document(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeAssignParticipantsRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'config': _ => de_Document(_, context),
+        'participants': _ => de_ParticipantIdList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeDescribeSaveFileRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'profile': _ => de_Document(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeGetGameResultRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'pluginState': _ => de_Document(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeGetGameStatusRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'pluginState': _ => de_Document(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeGetMetadataRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined) {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeGetPlayerViewRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'participantId': __expectString,
+        'pluginState': _ => de_Document(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeGetSaveFileEditorStateRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'profile': _ => de_Document(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeHealthRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined) {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeInitializeGameRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'config': _ => de_Document(_, context),
+        'participants': _ => de_ParticipantIdList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeIsConfigMoveRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'payload': _ => de_Document(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeIsOutOfTurnMoveRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'payload': _ => de_Document(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeSelectBotMoveRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'participantId': __expectString,
+        'pluginState': _ => de_Document(_, context),
+        'skillLevel': __expectString,
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const deserializeValidateMoveRequest = async (output, context) => {
+    const contentTypeHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'content-type');
+    if (contentTypeHeaderKey != null) {
+        const contentType = output.headers[contentTypeHeaderKey];
+        if (contentType !== undefined && contentType !== "application/json") {
+            throw new __UnsupportedMediaTypeException();
+        }
+        ;
+    }
+    ;
+    const acceptHeaderKey = Object.keys(output.headers).find(key => key.toLowerCase() === 'accept');
+    if (acceptHeaderKey != null) {
+        const accept = output.headers[acceptHeaderKey];
+        if (!__acceptMatches(accept, "application/json")) {
+            throw new __NotAcceptableException();
+        }
+        ;
+    }
+    ;
+    const contents = map({});
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'move': _ => de_Move(_, context),
+        'participantId': __expectString,
+        'pluginState': _ => de_Document(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const serializeApplyMoveResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'nextTurnParticipantId': [],
+        'pluginState': _ => se_Document(_, context),
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeApplySaveFileEditResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'profile': _ => se_Document(_, context),
+        'state': _ => se_Document(_, context),
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeAssignParticipantsResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'participants': _ => se_ParticipantIdList(_, context),
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeDescribeSaveFileResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'summary': [],
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeGetGameResultResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'outcome': [],
+        'winners': _ => se_ParticipantIdList(_, context),
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeGetGameStatusResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'isGameOver': [],
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeGetMetadataResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'botSkillLevels': _ => se_BotSkillLevelList(_, context),
+        'configSchema': _ => se_Document(_, context),
+        'displayName': [],
+        'hasBotStrategy': [],
+        'hasConfigMove': [],
+        'hasCustomPlayerView': [],
+        'hasOutOfTurnMove': [],
+        'hasSaveFileEditor': [],
+        'hasSaveFiles': [],
+        'hasSaveSummary': [],
+        'id': [],
+        'maxPlayers': [],
+        'minPlayers': [],
+        'spectatorSafe': [],
+        'teamPlay': [],
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeGetPlayerViewResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'pluginState': _ => se_Document(_, context),
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeGetSaveFileEditorStateResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'state': _ => se_Document(_, context),
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeHealthResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'gameType': [],
+        'protocolVersion': [],
+        'status': [],
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeInitializeGameResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'nextTurnParticipantId': [],
+        'pluginState': _ => se_Document(_, context),
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeIsConfigMoveResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'isConfigMove': [],
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeIsOutOfTurnMoveResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'isOutOfTurnMove': [],
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeSelectBotMoveResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'payload': _ => se_Document(_, context),
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeValidateMoveResponse = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    let statusCode = 200;
+    let headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'reason': [],
+        'valid': [],
+    }));
+    if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf('content-length') === -1) {
+        const length = calculateBodyLength(body);
+        if (length !== undefined) {
+            headers = { ...headers, 'content-length': String(length) };
+        }
+    }
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeFrameworkException = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    switch (input.name) {
+        case "InternalFailure": {
+            const statusCode = 500;
+            let headers = map({}, isSerializableHeaderValue, {
+                'x-amzn-errortype': "InternalFailure",
+                'content-type': 'application/json',
+            });
+            let body;
+            body = "{}";
+            return new __HttpResponse({
+                headers,
+                body,
+                statusCode,
+            });
+        }
+        case "NotAcceptableException": {
+            const statusCode = 406;
+            let headers = map({}, isSerializableHeaderValue, {
+                'x-amzn-errortype': "NotAcceptableException",
+                'content-type': 'application/json',
+            });
+            let body;
+            body = "{}";
+            return new __HttpResponse({
+                headers,
+                body,
+                statusCode,
+            });
+        }
+        case "SerializationException": {
+            const statusCode = 400;
+            let headers = map({}, isSerializableHeaderValue, {
+                'x-amzn-errortype': "SerializationException",
+                'content-type': 'application/json',
+            });
+            let body;
+            body = "{}";
+            return new __HttpResponse({
+                headers,
+                body,
+                statusCode,
+            });
+        }
+        case "UnknownOperationException": {
+            const statusCode = 404;
+            let headers = map({}, isSerializableHeaderValue, {
+                'x-amzn-errortype': "UnknownOperationException",
+                'content-type': 'application/json',
+            });
+            let body;
+            body = "{}";
+            return new __HttpResponse({
+                headers,
+                body,
+                statusCode,
+            });
+        }
+        case "UnsupportedMediaTypeException": {
+            const statusCode = 415;
+            let headers = map({}, isSerializableHeaderValue, {
+                'x-amzn-errortype': "UnsupportedMediaTypeException",
+                'content-type': 'application/json',
+            });
+            let body;
+            body = "{}";
+            return new __HttpResponse({
+                headers,
+                body,
+                statusCode,
+            });
+        }
+    }
+};
+export const serializeInvalidMoveErrorError = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    const statusCode = 400;
+    let headers = map({}, isSerializableHeaderValue, {
+        'x-amzn-errortype': "InvalidMoveError",
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'message': [],
+    }));
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeSaveFileEditRejectedErrorError = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    const statusCode = 400;
+    let headers = map({}, isSerializableHeaderValue, {
+        'x-amzn-errortype': "SaveFileEditRejectedError",
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'reason': [],
+    }));
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+const se_BotSkillLevelEntry = (input, context) => {
+    return take(input, {
+        'displayName': [],
+        'id': [],
+    });
+};
+const se_BotSkillLevelList = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_BotSkillLevelEntry(entry, context);
+    });
+};
+const se_ParticipantIdList = (input, context) => {
+    return input.filter((e) => e != null);
+};
+const se_Document = (input, context) => {
+    return input;
+};
+const de_Move = (output, context) => {
+    return take(output, {
+        'participantId': __expectString,
+        'payload': (_) => de_Document(_, context),
+        'sequenceNumber': __expectInt32,
+        'timestamp': (_) => __expectNonNull(__parseRfc3339DateTime(_)),
+    });
+};
+const de_ParticipantIdList = (output, context) => {
+    const retVal = (output || []).map((entry) => {
+        if (entry === null) {
+            throw new TypeError('All elements of the non-sparse list "com.boardgame.plugin#ParticipantIdList" must be non-null.');
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
+const de_Document = (output, context) => {
+    return output;
+};
+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));