@anweather/game-plugin-ssdk 1.2.0

package/dist-es/src/server/GamePluginService.js

@@ -0,0 +1,226 @@
+import { serializeFrameworkException } from "../protocols/Aws_restJson1";
+import { ApplyMoveSerializer, ApplyMoveServerInput, } from "./operations/ApplyMove";
+import { ApplySaveFileEditSerializer, ApplySaveFileEditServerInput, } from "./operations/ApplySaveFileEdit";
+import { AssignParticipantsSerializer, AssignParticipantsServerInput, } from "./operations/AssignParticipants";
+import { DescribeSaveFileSerializer, DescribeSaveFileServerInput, } from "./operations/DescribeSaveFile";
+import { GetGameResultSerializer, GetGameResultServerInput, } from "./operations/GetGameResult";
+import { GetGameStatusSerializer, GetGameStatusServerInput, } from "./operations/GetGameStatus";
+import { GetMetadataSerializer, GetMetadataServerInput, } from "./operations/GetMetadata";
+import { GetPlayerViewSerializer, GetPlayerViewServerInput, } from "./operations/GetPlayerView";
+import { GetSaveFileEditorStateSerializer, GetSaveFileEditorStateServerInput, } from "./operations/GetSaveFileEditorState";
+import { HealthSerializer, HealthServerInput, } from "./operations/Health";
+import { InitializeGameSerializer, InitializeGameServerInput, } from "./operations/InitializeGame";
+import { IsConfigMoveSerializer, IsConfigMoveServerInput, } from "./operations/IsConfigMove";
+import { IsOutOfTurnMoveSerializer, IsOutOfTurnMoveServerInput, } from "./operations/IsOutOfTurnMove";
+import { SelectBotMoveSerializer, SelectBotMoveServerInput, } from "./operations/SelectBotMove";
+import { ValidateMoveSerializer, ValidateMoveServerInput, } from "./operations/ValidateMove";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, UnknownOperationException as __UnknownOperationException, isFrameworkException as __isFrameworkException, httpbinding, } from "@aws-smithy/server-common";
+import { NodeHttpHandler, streamCollector, } from "@smithy/node-http-handler";
+import { fromBase64, toBase64, } from "@smithy/util-base64";
+import { fromUtf8, toUtf8, } from "@smithy/util-utf8";
+const serdeContextBase = {
+    base64Encoder: toBase64,
+    base64Decoder: fromBase64,
+    utf8Encoder: toUtf8,
+    utf8Decoder: fromUtf8,
+    streamCollector: streamCollector,
+    requestHandler: new NodeHttpHandler(),
+    disableHostPrefix: true
+};
+async function handle(request, context, operationName, serializer, operation, serializeFrameworkException, validationFn, validationCustomizer) {
+    let input;
+    try {
+        input = await serializer.deserialize(request, {
+            endpoint: () => Promise.resolve(request), ...serdeContextBase
+        });
+    }
+    catch (error) {
+        if (__isFrameworkException(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new __SerializationException(), serdeContextBase);
+    }
+    try {
+        let validationFailures = validationFn(input);
+        if (validationFailures && validationFailures.length > 0) {
+            let validationException = validationCustomizer({ operation: operationName }, validationFailures);
+            if (validationException) {
+                return serializer.serializeError(validationException, serdeContextBase);
+            }
+        }
+        let output = await operation(input, context);
+        return serializer.serialize(output, serdeContextBase);
+    }
+    catch (error) {
+        if (serializer.isOperationError(error)) {
+            return serializer.serializeError(error, serdeContextBase);
+        }
+        console.log('Received an unexpected error', error);
+        return serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+    }
+}
+export class GamePluginServiceHandler {
+    service;
+    mux;
+    serializerFactory;
+    serializeFrameworkException;
+    validationCustomizer;
+    constructor(service, mux, serializerFactory, serializeFrameworkException, validationCustomizer) {
+        this.service = service;
+        this.mux = mux;
+        this.serializerFactory = serializerFactory;
+        this.serializeFrameworkException = serializeFrameworkException;
+        this.validationCustomizer = validationCustomizer;
+    }
+    async handle(request, context) {
+        const target = this.mux.match(request);
+        if (target === undefined) {
+            return this.serializeFrameworkException(new __UnknownOperationException(), serdeContextBase);
+        }
+        switch (target.operation) {
+            case "ApplyMove": {
+                return handle(request, context, "ApplyMove", this.serializerFactory("ApplyMove"), this.service.ApplyMove, this.serializeFrameworkException, ApplyMoveServerInput.validate, this.validationCustomizer);
+            }
+            case "ApplySaveFileEdit": {
+                return handle(request, context, "ApplySaveFileEdit", this.serializerFactory("ApplySaveFileEdit"), this.service.ApplySaveFileEdit, this.serializeFrameworkException, ApplySaveFileEditServerInput.validate, this.validationCustomizer);
+            }
+            case "AssignParticipants": {
+                return handle(request, context, "AssignParticipants", this.serializerFactory("AssignParticipants"), this.service.AssignParticipants, this.serializeFrameworkException, AssignParticipantsServerInput.validate, this.validationCustomizer);
+            }
+            case "DescribeSaveFile": {
+                return handle(request, context, "DescribeSaveFile", this.serializerFactory("DescribeSaveFile"), this.service.DescribeSaveFile, this.serializeFrameworkException, DescribeSaveFileServerInput.validate, this.validationCustomizer);
+            }
+            case "GetGameResult": {
+                return handle(request, context, "GetGameResult", this.serializerFactory("GetGameResult"), this.service.GetGameResult, this.serializeFrameworkException, GetGameResultServerInput.validate, this.validationCustomizer);
+            }
+            case "GetGameStatus": {
+                return handle(request, context, "GetGameStatus", this.serializerFactory("GetGameStatus"), this.service.GetGameStatus, this.serializeFrameworkException, GetGameStatusServerInput.validate, this.validationCustomizer);
+            }
+            case "GetMetadata": {
+                return handle(request, context, "GetMetadata", this.serializerFactory("GetMetadata"), this.service.GetMetadata, this.serializeFrameworkException, GetMetadataServerInput.validate, this.validationCustomizer);
+            }
+            case "GetPlayerView": {
+                return handle(request, context, "GetPlayerView", this.serializerFactory("GetPlayerView"), this.service.GetPlayerView, this.serializeFrameworkException, GetPlayerViewServerInput.validate, this.validationCustomizer);
+            }
+            case "GetSaveFileEditorState": {
+                return handle(request, context, "GetSaveFileEditorState", this.serializerFactory("GetSaveFileEditorState"), this.service.GetSaveFileEditorState, this.serializeFrameworkException, GetSaveFileEditorStateServerInput.validate, this.validationCustomizer);
+            }
+            case "Health": {
+                return handle(request, context, "Health", this.serializerFactory("Health"), this.service.Health, this.serializeFrameworkException, HealthServerInput.validate, this.validationCustomizer);
+            }
+            case "InitializeGame": {
+                return handle(request, context, "InitializeGame", this.serializerFactory("InitializeGame"), this.service.InitializeGame, this.serializeFrameworkException, InitializeGameServerInput.validate, this.validationCustomizer);
+            }
+            case "IsConfigMove": {
+                return handle(request, context, "IsConfigMove", this.serializerFactory("IsConfigMove"), this.service.IsConfigMove, this.serializeFrameworkException, IsConfigMoveServerInput.validate, this.validationCustomizer);
+            }
+            case "IsOutOfTurnMove": {
+                return handle(request, context, "IsOutOfTurnMove", this.serializerFactory("IsOutOfTurnMove"), this.service.IsOutOfTurnMove, this.serializeFrameworkException, IsOutOfTurnMoveServerInput.validate, this.validationCustomizer);
+            }
+            case "SelectBotMove": {
+                return handle(request, context, "SelectBotMove", this.serializerFactory("SelectBotMove"), this.service.SelectBotMove, this.serializeFrameworkException, SelectBotMoveServerInput.validate, this.validationCustomizer);
+            }
+            case "ValidateMove": {
+                return handle(request, context, "ValidateMove", this.serializerFactory("ValidateMove"), this.service.ValidateMove, this.serializeFrameworkException, ValidateMoveServerInput.validate, this.validationCustomizer);
+            }
+        }
+    }
+}
+export const getGamePluginServiceHandler = (service, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "moves" },
+            { type: 'path_literal', value: "apply" },
+        ], [], { service: "GamePlugin", operation: "ApplyMove" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "saves" },
+            { type: 'path_literal', value: "editor-edit" },
+        ], [], { service: "GamePlugin", operation: "ApplySaveFileEdit" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "participants" },
+            { type: 'path_literal', value: "assign" },
+        ], [], { service: "GamePlugin", operation: "AssignParticipants" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "saves" },
+            { type: 'path_literal', value: "describe" },
+        ], [], { service: "GamePlugin", operation: "DescribeSaveFile" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "games" },
+            { type: 'path_literal', value: "result" },
+        ], [], { service: "GamePlugin", operation: "GetGameResult" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "games" },
+            { type: 'path_literal', value: "status" },
+        ], [], { service: "GamePlugin", operation: "GetGameStatus" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "metadata" },
+        ], [], { service: "GamePlugin", operation: "GetMetadata" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "games" },
+            { type: 'path_literal', value: "player-view" },
+        ], [], { service: "GamePlugin", operation: "GetPlayerView" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "saves" },
+            { type: 'path_literal', value: "editor-state" },
+        ], [], { service: "GamePlugin", operation: "GetSaveFileEditorState" }),
+        new httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "health" },
+        ], [], { service: "GamePlugin", operation: "Health" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "games" },
+            { type: 'path_literal', value: "initialize" },
+        ], [], { service: "GamePlugin", operation: "InitializeGame" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "moves" },
+            { type: 'path_literal', value: "is-config" },
+        ], [], { service: "GamePlugin", operation: "IsConfigMove" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "moves" },
+            { type: 'path_literal', value: "is-out-of-turn" },
+        ], [], { service: "GamePlugin", operation: "IsOutOfTurnMove" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "bots" },
+            { type: 'path_literal', value: "select-move" },
+        ], [], { service: "GamePlugin", operation: "SelectBotMove" }),
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "moves" },
+            { type: 'path_literal', value: "validate" },
+        ], [], { service: "GamePlugin", operation: "ValidateMove" }),
+    ]);
+    const serFn = (op) => {
+        switch (op) {
+            case "ApplyMove": return new ApplyMoveSerializer();
+            case "ApplySaveFileEdit": return new ApplySaveFileEditSerializer();
+            case "AssignParticipants": return new AssignParticipantsSerializer();
+            case "DescribeSaveFile": return new DescribeSaveFileSerializer();
+            case "GetGameResult": return new GetGameResultSerializer();
+            case "GetGameStatus": return new GetGameStatusSerializer();
+            case "GetMetadata": return new GetMetadataSerializer();
+            case "GetPlayerView": return new GetPlayerViewSerializer();
+            case "GetSaveFileEditorState": return new GetSaveFileEditorStateSerializer();
+            case "Health": return new HealthSerializer();
+            case "InitializeGame": return new InitializeGameSerializer();
+            case "IsConfigMove": return new IsConfigMoveSerializer();
+            case "IsOutOfTurnMove": return new IsOutOfTurnMoveSerializer();
+            case "SelectBotMove": return new SelectBotMoveSerializer();
+            case "ValidateMove": return new ValidateMoveSerializer();
+        }
+    };
+    return new GamePluginServiceHandler(service, mux, serFn, serializeFrameworkException, customizer);
+};

package/dist-es/src/server/index.js

@@ -0,0 +1,2 @@
+export * from "./operations";
+export * from "./GamePluginService";

package/dist-es/src/server/operations/ApplyMove.js

@@ -0,0 +1,103 @@
+import { ApplyMoveInput, } from "../../models/models_0";
+import { deserializeApplyMoveRequest, serializeApplyMoveResponse, serializeFrameworkException, serializeInvalidMoveErrorError, } from "../../protocols/Aws_restJson1";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, isFrameworkException as __isFrameworkException, httpbinding, } from "@aws-smithy/server-common";
+import { NodeHttpHandler, streamCollector, } from "@smithy/node-http-handler";
+import { fromBase64, toBase64, } from "@smithy/util-base64";
+import { fromUtf8, toUtf8, } from "@smithy/util-utf8";
+export var ApplyMoveServerInput;
+(function (ApplyMoveServerInput) {
+    ApplyMoveServerInput.validate = ApplyMoveInput.validate;
+})(ApplyMoveServerInput || (ApplyMoveServerInput = {}));
+export class ApplyMoveSerializer {
+    serialize = serializeApplyMoveResponse;
+    deserialize = deserializeApplyMoveRequest;
+    isOperationError(error) {
+        const names = ["InvalidMoveError"];
+        return names.includes(error.name);
+    }
+    ;
+    serializeError(error, ctx) {
+        switch (error.name) {
+            case "InvalidMoveError": {
+                return serializeInvalidMoveErrorError(error, ctx);
+            }
+            default: {
+                throw error;
+            }
+        }
+    }
+}
+export const getApplyMoveHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "moves" },
+            { type: 'path_literal', value: "apply" },
+        ], [], { service: "GamePlugin", operation: "ApplyMove" }),
+    ]);
+    return new ApplyMoveHandler(operation, mux, new ApplyMoveSerializer(), serializeFrameworkException, customizer);
+};
+const serdeContextBase = {
+    base64Encoder: toBase64,
+    base64Decoder: fromBase64,
+    utf8Encoder: toUtf8,
+    utf8Decoder: fromUtf8,
+    streamCollector: streamCollector,
+    requestHandler: new NodeHttpHandler(),
+    disableHostPrefix: true
+};
+async function handle(request, context, operationName, serializer, operation, serializeFrameworkException, validationFn, validationCustomizer) {
+    let input;
+    try {
+        input = await serializer.deserialize(request, {
+            endpoint: () => Promise.resolve(request), ...serdeContextBase
+        });
+    }
+    catch (error) {
+        if (__isFrameworkException(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new __SerializationException(), serdeContextBase);
+    }
+    try {
+        let validationFailures = validationFn(input);
+        if (validationFailures && validationFailures.length > 0) {
+            let validationException = validationCustomizer({ operation: operationName }, validationFailures);
+            if (validationException) {
+                return serializer.serializeError(validationException, serdeContextBase);
+            }
+        }
+        let output = await operation(input, context);
+        return serializer.serialize(output, serdeContextBase);
+    }
+    catch (error) {
+        if (serializer.isOperationError(error)) {
+            return serializer.serializeError(error, serdeContextBase);
+        }
+        console.log('Received an unexpected error', error);
+        return serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+    }
+}
+export class ApplyMoveHandler {
+    operation;
+    mux;
+    serializer;
+    serializeFrameworkException;
+    validationCustomizer;
+    constructor(operation, mux, serializer, serializeFrameworkException, validationCustomizer) {
+        this.operation = operation;
+        this.mux = mux;
+        this.serializer = serializer;
+        this.serializeFrameworkException = serializeFrameworkException;
+        this.validationCustomizer = validationCustomizer;
+    }
+    async handle(request, context) {
+        const target = this.mux.match(request);
+        if (target === undefined) {
+            console.log('Received a request that did not match com.boardgame.plugin#GamePlugin.ApplyMove. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "ApplyMove", this.serializer, this.operation, this.serializeFrameworkException, ApplyMoveServerInput.validate, this.validationCustomizer);
+    }
+}

package/dist-es/src/server/operations/ApplySaveFileEdit.js

@@ -0,0 +1,103 @@
+import { ApplySaveFileEditInput, } from "../../models/models_0";
+import { deserializeApplySaveFileEditRequest, serializeApplySaveFileEditResponse, serializeFrameworkException, serializeSaveFileEditRejectedErrorError, } from "../../protocols/Aws_restJson1";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, isFrameworkException as __isFrameworkException, httpbinding, } from "@aws-smithy/server-common";
+import { NodeHttpHandler, streamCollector, } from "@smithy/node-http-handler";
+import { fromBase64, toBase64, } from "@smithy/util-base64";
+import { fromUtf8, toUtf8, } from "@smithy/util-utf8";
+export var ApplySaveFileEditServerInput;
+(function (ApplySaveFileEditServerInput) {
+    ApplySaveFileEditServerInput.validate = ApplySaveFileEditInput.validate;
+})(ApplySaveFileEditServerInput || (ApplySaveFileEditServerInput = {}));
+export class ApplySaveFileEditSerializer {
+    serialize = serializeApplySaveFileEditResponse;
+    deserialize = deserializeApplySaveFileEditRequest;
+    isOperationError(error) {
+        const names = ["SaveFileEditRejectedError"];
+        return names.includes(error.name);
+    }
+    ;
+    serializeError(error, ctx) {
+        switch (error.name) {
+            case "SaveFileEditRejectedError": {
+                return serializeSaveFileEditRejectedErrorError(error, ctx);
+            }
+            default: {
+                throw error;
+            }
+        }
+    }
+}
+export const getApplySaveFileEditHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "saves" },
+            { type: 'path_literal', value: "editor-edit" },
+        ], [], { service: "GamePlugin", operation: "ApplySaveFileEdit" }),
+    ]);
+    return new ApplySaveFileEditHandler(operation, mux, new ApplySaveFileEditSerializer(), serializeFrameworkException, customizer);
+};
+const serdeContextBase = {
+    base64Encoder: toBase64,
+    base64Decoder: fromBase64,
+    utf8Encoder: toUtf8,
+    utf8Decoder: fromUtf8,
+    streamCollector: streamCollector,
+    requestHandler: new NodeHttpHandler(),
+    disableHostPrefix: true
+};
+async function handle(request, context, operationName, serializer, operation, serializeFrameworkException, validationFn, validationCustomizer) {
+    let input;
+    try {
+        input = await serializer.deserialize(request, {
+            endpoint: () => Promise.resolve(request), ...serdeContextBase
+        });
+    }
+    catch (error) {
+        if (__isFrameworkException(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new __SerializationException(), serdeContextBase);
+    }
+    try {
+        let validationFailures = validationFn(input);
+        if (validationFailures && validationFailures.length > 0) {
+            let validationException = validationCustomizer({ operation: operationName }, validationFailures);
+            if (validationException) {
+                return serializer.serializeError(validationException, serdeContextBase);
+            }
+        }
+        let output = await operation(input, context);
+        return serializer.serialize(output, serdeContextBase);
+    }
+    catch (error) {
+        if (serializer.isOperationError(error)) {
+            return serializer.serializeError(error, serdeContextBase);
+        }
+        console.log('Received an unexpected error', error);
+        return serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+    }
+}
+export class ApplySaveFileEditHandler {
+    operation;
+    mux;
+    serializer;
+    serializeFrameworkException;
+    validationCustomizer;
+    constructor(operation, mux, serializer, serializeFrameworkException, validationCustomizer) {
+        this.operation = operation;
+        this.mux = mux;
+        this.serializer = serializer;
+        this.serializeFrameworkException = serializeFrameworkException;
+        this.validationCustomizer = validationCustomizer;
+    }
+    async handle(request, context) {
+        const target = this.mux.match(request);
+        if (target === undefined) {
+            console.log('Received a request that did not match com.boardgame.plugin#GamePlugin.ApplySaveFileEdit. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "ApplySaveFileEdit", this.serializer, this.operation, this.serializeFrameworkException, ApplySaveFileEditServerInput.validate, this.validationCustomizer);
+    }
+}

package/dist-es/src/server/operations/AssignParticipants.js

@@ -0,0 +1,95 @@
+import { AssignParticipantsInput, } from "../../models/models_0";
+import { deserializeAssignParticipantsRequest, serializeAssignParticipantsResponse, serializeFrameworkException, } from "../../protocols/Aws_restJson1";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, isFrameworkException as __isFrameworkException, httpbinding, } from "@aws-smithy/server-common";
+import { NodeHttpHandler, streamCollector, } from "@smithy/node-http-handler";
+import { fromBase64, toBase64, } from "@smithy/util-base64";
+import { fromUtf8, toUtf8, } from "@smithy/util-utf8";
+export var AssignParticipantsServerInput;
+(function (AssignParticipantsServerInput) {
+    AssignParticipantsServerInput.validate = AssignParticipantsInput.validate;
+})(AssignParticipantsServerInput || (AssignParticipantsServerInput = {}));
+export class AssignParticipantsSerializer {
+    serialize = serializeAssignParticipantsResponse;
+    deserialize = deserializeAssignParticipantsRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getAssignParticipantsHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "participants" },
+            { type: 'path_literal', value: "assign" },
+        ], [], { service: "GamePlugin", operation: "AssignParticipants" }),
+    ]);
+    return new AssignParticipantsHandler(operation, mux, new AssignParticipantsSerializer(), serializeFrameworkException, customizer);
+};
+const serdeContextBase = {
+    base64Encoder: toBase64,
+    base64Decoder: fromBase64,
+    utf8Encoder: toUtf8,
+    utf8Decoder: fromUtf8,
+    streamCollector: streamCollector,
+    requestHandler: new NodeHttpHandler(),
+    disableHostPrefix: true
+};
+async function handle(request, context, operationName, serializer, operation, serializeFrameworkException, validationFn, validationCustomizer) {
+    let input;
+    try {
+        input = await serializer.deserialize(request, {
+            endpoint: () => Promise.resolve(request), ...serdeContextBase
+        });
+    }
+    catch (error) {
+        if (__isFrameworkException(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new __SerializationException(), serdeContextBase);
+    }
+    try {
+        let validationFailures = validationFn(input);
+        if (validationFailures && validationFailures.length > 0) {
+            let validationException = validationCustomizer({ operation: operationName }, validationFailures);
+            if (validationException) {
+                return serializer.serializeError(validationException, serdeContextBase);
+            }
+        }
+        let output = await operation(input, context);
+        return serializer.serialize(output, serdeContextBase);
+    }
+    catch (error) {
+        if (serializer.isOperationError(error)) {
+            return serializer.serializeError(error, serdeContextBase);
+        }
+        console.log('Received an unexpected error', error);
+        return serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+    }
+}
+export class AssignParticipantsHandler {
+    operation;
+    mux;
+    serializer;
+    serializeFrameworkException;
+    validationCustomizer;
+    constructor(operation, mux, serializer, serializeFrameworkException, validationCustomizer) {
+        this.operation = operation;
+        this.mux = mux;
+        this.serializer = serializer;
+        this.serializeFrameworkException = serializeFrameworkException;
+        this.validationCustomizer = validationCustomizer;
+    }
+    async handle(request, context) {
+        const target = this.mux.match(request);
+        if (target === undefined) {
+            console.log('Received a request that did not match com.boardgame.plugin#GamePlugin.AssignParticipants. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "AssignParticipants", this.serializer, this.operation, this.serializeFrameworkException, AssignParticipantsServerInput.validate, this.validationCustomizer);
+    }
+}

package/dist-es/src/server/operations/DescribeSaveFile.js

@@ -0,0 +1,95 @@
+import { DescribeSaveFileInput, } from "../../models/models_0";
+import { deserializeDescribeSaveFileRequest, serializeDescribeSaveFileResponse, serializeFrameworkException, } from "../../protocols/Aws_restJson1";
+import { InternalFailureException as __InternalFailureException, SerializationException as __SerializationException, isFrameworkException as __isFrameworkException, httpbinding, } from "@aws-smithy/server-common";
+import { NodeHttpHandler, streamCollector, } from "@smithy/node-http-handler";
+import { fromBase64, toBase64, } from "@smithy/util-base64";
+import { fromUtf8, toUtf8, } from "@smithy/util-utf8";
+export var DescribeSaveFileServerInput;
+(function (DescribeSaveFileServerInput) {
+    DescribeSaveFileServerInput.validate = DescribeSaveFileInput.validate;
+})(DescribeSaveFileServerInput || (DescribeSaveFileServerInput = {}));
+export class DescribeSaveFileSerializer {
+    serialize = serializeDescribeSaveFileResponse;
+    deserialize = deserializeDescribeSaveFileRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+export const getDescribeSaveFileHandler = (operation, customizer) => {
+    const mux = new httpbinding.HttpBindingMux([
+        new httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "saves" },
+            { type: 'path_literal', value: "describe" },
+        ], [], { service: "GamePlugin", operation: "DescribeSaveFile" }),
+    ]);
+    return new DescribeSaveFileHandler(operation, mux, new DescribeSaveFileSerializer(), serializeFrameworkException, customizer);
+};
+const serdeContextBase = {
+    base64Encoder: toBase64,
+    base64Decoder: fromBase64,
+    utf8Encoder: toUtf8,
+    utf8Decoder: fromUtf8,
+    streamCollector: streamCollector,
+    requestHandler: new NodeHttpHandler(),
+    disableHostPrefix: true
+};
+async function handle(request, context, operationName, serializer, operation, serializeFrameworkException, validationFn, validationCustomizer) {
+    let input;
+    try {
+        input = await serializer.deserialize(request, {
+            endpoint: () => Promise.resolve(request), ...serdeContextBase
+        });
+    }
+    catch (error) {
+        if (__isFrameworkException(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new __SerializationException(), serdeContextBase);
+    }
+    try {
+        let validationFailures = validationFn(input);
+        if (validationFailures && validationFailures.length > 0) {
+            let validationException = validationCustomizer({ operation: operationName }, validationFailures);
+            if (validationException) {
+                return serializer.serializeError(validationException, serdeContextBase);
+            }
+        }
+        let output = await operation(input, context);
+        return serializer.serialize(output, serdeContextBase);
+    }
+    catch (error) {
+        if (serializer.isOperationError(error)) {
+            return serializer.serializeError(error, serdeContextBase);
+        }
+        console.log('Received an unexpected error', error);
+        return serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+    }
+}
+export class DescribeSaveFileHandler {
+    operation;
+    mux;
+    serializer;
+    serializeFrameworkException;
+    validationCustomizer;
+    constructor(operation, mux, serializer, serializeFrameworkException, validationCustomizer) {
+        this.operation = operation;
+        this.mux = mux;
+        this.serializer = serializer;
+        this.serializeFrameworkException = serializeFrameworkException;
+        this.validationCustomizer = validationCustomizer;
+    }
+    async handle(request, context) {
+        const target = this.mux.match(request);
+        if (target === undefined) {
+            console.log('Received a request that did not match com.boardgame.plugin#GamePlugin.DescribeSaveFile. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new __InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "DescribeSaveFile", this.serializer, this.operation, this.serializeFrameworkException, DescribeSaveFileServerInput.validate, this.validationCustomizer);
+    }
+}