@anweather/game-plugin-ssdk 1.2.0

package/dist-cjs/src/server/operations/GetGameResult.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetGameResultHandler = exports.getGetGameResultHandler = exports.GetGameResultSerializer = exports.GetGameResultServerInput = void 0;
+const models_0_1 = require("../../models/models_0");
+const Aws_restJson1_1 = require("../../protocols/Aws_restJson1");
+const server_common_1 = require("@aws-smithy/server-common");
+const node_http_handler_1 = require("@smithy/node-http-handler");
+const util_base64_1 = require("@smithy/util-base64");
+const util_utf8_1 = require("@smithy/util-utf8");
+var GetGameResultServerInput;
+(function (GetGameResultServerInput) {
+    GetGameResultServerInput.validate = models_0_1.PluginStateOnlyInput.validate;
+})(GetGameResultServerInput || (exports.GetGameResultServerInput = GetGameResultServerInput = {}));
+class GetGameResultSerializer {
+    serialize = Aws_restJson1_1.serializeGetGameResultResponse;
+    deserialize = Aws_restJson1_1.deserializeGetGameResultRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+exports.GetGameResultSerializer = GetGameResultSerializer;
+const getGetGameResultHandler = (operation, customizer) => {
+    const mux = new server_common_1.httpbinding.HttpBindingMux([
+        new server_common_1.httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "games" },
+            { type: 'path_literal', value: "result" },
+        ], [], { service: "GamePlugin", operation: "GetGameResult" }),
+    ]);
+    return new GetGameResultHandler(operation, mux, new GetGameResultSerializer(), Aws_restJson1_1.serializeFrameworkException, customizer);
+};
+exports.getGetGameResultHandler = getGetGameResultHandler;
+const serdeContextBase = {
+    base64Encoder: util_base64_1.toBase64,
+    base64Decoder: util_base64_1.fromBase64,
+    utf8Encoder: util_utf8_1.toUtf8,
+    utf8Decoder: util_utf8_1.fromUtf8,
+    streamCollector: node_http_handler_1.streamCollector,
+    requestHandler: new node_http_handler_1.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 ((0, server_common_1.isFrameworkException)(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new server_common_1.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 server_common_1.InternalFailureException(), serdeContextBase);
+    }
+}
+class GetGameResultHandler {
+    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.GetGameResult. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new server_common_1.InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetGameResult", this.serializer, this.operation, this.serializeFrameworkException, GetGameResultServerInput.validate, this.validationCustomizer);
+    }
+}
+exports.GetGameResultHandler = GetGameResultHandler;

package/dist-cjs/src/server/operations/GetGameStatus.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetGameStatusHandler = exports.getGetGameStatusHandler = exports.GetGameStatusSerializer = exports.GetGameStatusServerInput = void 0;
+const models_0_1 = require("../../models/models_0");
+const Aws_restJson1_1 = require("../../protocols/Aws_restJson1");
+const server_common_1 = require("@aws-smithy/server-common");
+const node_http_handler_1 = require("@smithy/node-http-handler");
+const util_base64_1 = require("@smithy/util-base64");
+const util_utf8_1 = require("@smithy/util-utf8");
+var GetGameStatusServerInput;
+(function (GetGameStatusServerInput) {
+    GetGameStatusServerInput.validate = models_0_1.PluginStateOnlyInput.validate;
+})(GetGameStatusServerInput || (exports.GetGameStatusServerInput = GetGameStatusServerInput = {}));
+class GetGameStatusSerializer {
+    serialize = Aws_restJson1_1.serializeGetGameStatusResponse;
+    deserialize = Aws_restJson1_1.deserializeGetGameStatusRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+exports.GetGameStatusSerializer = GetGameStatusSerializer;
+const getGetGameStatusHandler = (operation, customizer) => {
+    const mux = new server_common_1.httpbinding.HttpBindingMux([
+        new server_common_1.httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "games" },
+            { type: 'path_literal', value: "status" },
+        ], [], { service: "GamePlugin", operation: "GetGameStatus" }),
+    ]);
+    return new GetGameStatusHandler(operation, mux, new GetGameStatusSerializer(), Aws_restJson1_1.serializeFrameworkException, customizer);
+};
+exports.getGetGameStatusHandler = getGetGameStatusHandler;
+const serdeContextBase = {
+    base64Encoder: util_base64_1.toBase64,
+    base64Decoder: util_base64_1.fromBase64,
+    utf8Encoder: util_utf8_1.toUtf8,
+    utf8Decoder: util_utf8_1.fromUtf8,
+    streamCollector: node_http_handler_1.streamCollector,
+    requestHandler: new node_http_handler_1.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 ((0, server_common_1.isFrameworkException)(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new server_common_1.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 server_common_1.InternalFailureException(), serdeContextBase);
+    }
+}
+class GetGameStatusHandler {
+    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.GetGameStatus. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new server_common_1.InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetGameStatus", this.serializer, this.operation, this.serializeFrameworkException, GetGameStatusServerInput.validate, this.validationCustomizer);
+    }
+}
+exports.GetGameStatusHandler = GetGameStatusHandler;

package/dist-cjs/src/server/operations/GetMetadata.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetMetadataHandler = exports.getGetMetadataHandler = exports.GetMetadataSerializer = exports.GetMetadataServerInput = void 0;
+const Aws_restJson1_1 = require("../../protocols/Aws_restJson1");
+const server_common_1 = require("@aws-smithy/server-common");
+const node_http_handler_1 = require("@smithy/node-http-handler");
+const util_base64_1 = require("@smithy/util-base64");
+const util_utf8_1 = require("@smithy/util-utf8");
+var GetMetadataServerInput;
+(function (GetMetadataServerInput) {
+    GetMetadataServerInput.validate = () => [];
+})(GetMetadataServerInput || (exports.GetMetadataServerInput = GetMetadataServerInput = {}));
+class GetMetadataSerializer {
+    serialize = Aws_restJson1_1.serializeGetMetadataResponse;
+    deserialize = Aws_restJson1_1.deserializeGetMetadataRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+exports.GetMetadataSerializer = GetMetadataSerializer;
+const getGetMetadataHandler = (operation, customizer) => {
+    const mux = new server_common_1.httpbinding.HttpBindingMux([
+        new server_common_1.httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "metadata" },
+        ], [], { service: "GamePlugin", operation: "GetMetadata" }),
+    ]);
+    return new GetMetadataHandler(operation, mux, new GetMetadataSerializer(), Aws_restJson1_1.serializeFrameworkException, customizer);
+};
+exports.getGetMetadataHandler = getGetMetadataHandler;
+const serdeContextBase = {
+    base64Encoder: util_base64_1.toBase64,
+    base64Decoder: util_base64_1.fromBase64,
+    utf8Encoder: util_utf8_1.toUtf8,
+    utf8Decoder: util_utf8_1.fromUtf8,
+    streamCollector: node_http_handler_1.streamCollector,
+    requestHandler: new node_http_handler_1.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 ((0, server_common_1.isFrameworkException)(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new server_common_1.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 server_common_1.InternalFailureException(), serdeContextBase);
+    }
+}
+class GetMetadataHandler {
+    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.GetMetadata. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new server_common_1.InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetMetadata", this.serializer, this.operation, this.serializeFrameworkException, GetMetadataServerInput.validate, this.validationCustomizer);
+    }
+}
+exports.GetMetadataHandler = GetMetadataHandler;

package/dist-cjs/src/server/operations/GetPlayerView.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetPlayerViewHandler = exports.getGetPlayerViewHandler = exports.GetPlayerViewSerializer = exports.GetPlayerViewServerInput = void 0;
+const models_0_1 = require("../../models/models_0");
+const Aws_restJson1_1 = require("../../protocols/Aws_restJson1");
+const server_common_1 = require("@aws-smithy/server-common");
+const node_http_handler_1 = require("@smithy/node-http-handler");
+const util_base64_1 = require("@smithy/util-base64");
+const util_utf8_1 = require("@smithy/util-utf8");
+var GetPlayerViewServerInput;
+(function (GetPlayerViewServerInput) {
+    GetPlayerViewServerInput.validate = models_0_1.GetPlayerViewInput.validate;
+})(GetPlayerViewServerInput || (exports.GetPlayerViewServerInput = GetPlayerViewServerInput = {}));
+class GetPlayerViewSerializer {
+    serialize = Aws_restJson1_1.serializeGetPlayerViewResponse;
+    deserialize = Aws_restJson1_1.deserializeGetPlayerViewRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+exports.GetPlayerViewSerializer = GetPlayerViewSerializer;
+const getGetPlayerViewHandler = (operation, customizer) => {
+    const mux = new server_common_1.httpbinding.HttpBindingMux([
+        new server_common_1.httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "games" },
+            { type: 'path_literal', value: "player-view" },
+        ], [], { service: "GamePlugin", operation: "GetPlayerView" }),
+    ]);
+    return new GetPlayerViewHandler(operation, mux, new GetPlayerViewSerializer(), Aws_restJson1_1.serializeFrameworkException, customizer);
+};
+exports.getGetPlayerViewHandler = getGetPlayerViewHandler;
+const serdeContextBase = {
+    base64Encoder: util_base64_1.toBase64,
+    base64Decoder: util_base64_1.fromBase64,
+    utf8Encoder: util_utf8_1.toUtf8,
+    utf8Decoder: util_utf8_1.fromUtf8,
+    streamCollector: node_http_handler_1.streamCollector,
+    requestHandler: new node_http_handler_1.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 ((0, server_common_1.isFrameworkException)(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new server_common_1.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 server_common_1.InternalFailureException(), serdeContextBase);
+    }
+}
+class GetPlayerViewHandler {
+    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.GetPlayerView. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new server_common_1.InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetPlayerView", this.serializer, this.operation, this.serializeFrameworkException, GetPlayerViewServerInput.validate, this.validationCustomizer);
+    }
+}
+exports.GetPlayerViewHandler = GetPlayerViewHandler;

package/dist-cjs/src/server/operations/GetSaveFileEditorState.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSaveFileEditorStateHandler = exports.getGetSaveFileEditorStateHandler = exports.GetSaveFileEditorStateSerializer = exports.GetSaveFileEditorStateServerInput = void 0;
+const models_0_1 = require("../../models/models_0");
+const Aws_restJson1_1 = require("../../protocols/Aws_restJson1");
+const server_common_1 = require("@aws-smithy/server-common");
+const node_http_handler_1 = require("@smithy/node-http-handler");
+const util_base64_1 = require("@smithy/util-base64");
+const util_utf8_1 = require("@smithy/util-utf8");
+var GetSaveFileEditorStateServerInput;
+(function (GetSaveFileEditorStateServerInput) {
+    GetSaveFileEditorStateServerInput.validate = models_0_1.GetSaveFileEditorStateInput.validate;
+})(GetSaveFileEditorStateServerInput || (exports.GetSaveFileEditorStateServerInput = GetSaveFileEditorStateServerInput = {}));
+class GetSaveFileEditorStateSerializer {
+    serialize = Aws_restJson1_1.serializeGetSaveFileEditorStateResponse;
+    deserialize = Aws_restJson1_1.deserializeGetSaveFileEditorStateRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+exports.GetSaveFileEditorStateSerializer = GetSaveFileEditorStateSerializer;
+const getGetSaveFileEditorStateHandler = (operation, customizer) => {
+    const mux = new server_common_1.httpbinding.HttpBindingMux([
+        new server_common_1.httpbinding.UriSpec('POST', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "saves" },
+            { type: 'path_literal', value: "editor-state" },
+        ], [], { service: "GamePlugin", operation: "GetSaveFileEditorState" }),
+    ]);
+    return new GetSaveFileEditorStateHandler(operation, mux, new GetSaveFileEditorStateSerializer(), Aws_restJson1_1.serializeFrameworkException, customizer);
+};
+exports.getGetSaveFileEditorStateHandler = getGetSaveFileEditorStateHandler;
+const serdeContextBase = {
+    base64Encoder: util_base64_1.toBase64,
+    base64Decoder: util_base64_1.fromBase64,
+    utf8Encoder: util_utf8_1.toUtf8,
+    utf8Decoder: util_utf8_1.fromUtf8,
+    streamCollector: node_http_handler_1.streamCollector,
+    requestHandler: new node_http_handler_1.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 ((0, server_common_1.isFrameworkException)(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new server_common_1.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 server_common_1.InternalFailureException(), serdeContextBase);
+    }
+}
+class GetSaveFileEditorStateHandler {
+    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.GetSaveFileEditorState. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new server_common_1.InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "GetSaveFileEditorState", this.serializer, this.operation, this.serializeFrameworkException, GetSaveFileEditorStateServerInput.validate, this.validationCustomizer);
+    }
+}
+exports.GetSaveFileEditorStateHandler = GetSaveFileEditorStateHandler;

package/dist-cjs/src/server/operations/Health.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthHandler = exports.getHealthHandler = exports.HealthSerializer = exports.HealthServerInput = void 0;
+const Aws_restJson1_1 = require("../../protocols/Aws_restJson1");
+const server_common_1 = require("@aws-smithy/server-common");
+const node_http_handler_1 = require("@smithy/node-http-handler");
+const util_base64_1 = require("@smithy/util-base64");
+const util_utf8_1 = require("@smithy/util-utf8");
+var HealthServerInput;
+(function (HealthServerInput) {
+    HealthServerInput.validate = () => [];
+})(HealthServerInput || (exports.HealthServerInput = HealthServerInput = {}));
+class HealthSerializer {
+    serialize = Aws_restJson1_1.serializeHealthResponse;
+    deserialize = Aws_restJson1_1.deserializeHealthRequest;
+    isOperationError(error) {
+        return false;
+    }
+    ;
+    serializeError(error, ctx) {
+        throw error;
+    }
+}
+exports.HealthSerializer = HealthSerializer;
+const getHealthHandler = (operation, customizer) => {
+    const mux = new server_common_1.httpbinding.HttpBindingMux([
+        new server_common_1.httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "v1" },
+            { type: 'path_literal', value: "health" },
+        ], [], { service: "GamePlugin", operation: "Health" }),
+    ]);
+    return new HealthHandler(operation, mux, new HealthSerializer(), Aws_restJson1_1.serializeFrameworkException, customizer);
+};
+exports.getHealthHandler = getHealthHandler;
+const serdeContextBase = {
+    base64Encoder: util_base64_1.toBase64,
+    base64Decoder: util_base64_1.fromBase64,
+    utf8Encoder: util_utf8_1.toUtf8,
+    utf8Decoder: util_utf8_1.fromUtf8,
+    streamCollector: node_http_handler_1.streamCollector,
+    requestHandler: new node_http_handler_1.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 ((0, server_common_1.isFrameworkException)(error)) {
+            return serializeFrameworkException(error, serdeContextBase);
+        }
+        ;
+        return serializeFrameworkException(new server_common_1.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 server_common_1.InternalFailureException(), serdeContextBase);
+    }
+}
+class HealthHandler {
+    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.Health. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new server_common_1.InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "Health", this.serializer, this.operation, this.serializeFrameworkException, HealthServerInput.validate, this.validationCustomizer);
+    }
+}
+exports.HealthHandler = HealthHandler;