@sparkrewards/sra-sdk 0.0.1

package/dist-cjs/server/operations/PinnedShopPublic.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinnedShopPublicHandler = exports.getPinnedShopPublicHandler = exports.PinnedShopPublicSerializer = exports.PinnedShopPublicServerInput = 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 PinnedShopPublicServerInput;
+(function (PinnedShopPublicServerInput) {
+    PinnedShopPublicServerInput.validate = models_0_1.PinnedShopInput.validate;
+})(PinnedShopPublicServerInput = exports.PinnedShopPublicServerInput || (exports.PinnedShopPublicServerInput = {}));
+class PinnedShopPublicSerializer {
+    constructor() {
+        this.serialize = Aws_restJson1_1.serializePinnedShopPublicResponse;
+        this.deserialize = Aws_restJson1_1.deserializePinnedShopPublicRequest;
+    }
+    isOperationError(error) {
+        const names = ["ValidationException", "RuntimeError"];
+        return names.includes(error.name);
+    }
+    ;
+    serializeError(error, ctx) {
+        switch (error.name) {
+            case "ValidationException": {
+                return (0, Aws_restJson1_1.serializeValidationExceptionError)(error, ctx);
+            }
+            case "RuntimeError": {
+                return (0, Aws_restJson1_1.serializeRuntimeErrorError)(error, ctx);
+            }
+            default: {
+                throw error;
+            }
+        }
+    }
+}
+exports.PinnedShopPublicSerializer = PinnedShopPublicSerializer;
+const getPinnedShopPublicHandler = (operation) => {
+    const mux = new server_common_1.httpbinding.HttpBindingMux([
+        new server_common_1.httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "public" },
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "pinned" },
+        ], [
+            { type: 'query', key: "shop_id" },
+            { type: 'query', key: "lat" },
+            { type: 'query', key: "lon" },
+        ], { service: "AppAPI", operation: "PinnedShopPublic" }),
+    ]);
+    const customizer = (ctx, failures) => {
+        if (!failures) {
+            return undefined;
+        }
+        return {
+            name: "ValidationException",
+            $fault: "client",
+            message: (0, server_common_1.generateValidationSummary)(failures),
+            fieldList: failures.map(failure => ({
+                path: failure.path,
+                message: (0, server_common_1.generateValidationMessage)(failure)
+            }))
+        };
+    };
+    return new PinnedShopPublicHandler(operation, mux, new PinnedShopPublicSerializer(), Aws_restJson1_1.serializeFrameworkException, customizer);
+};
+exports.getPinnedShopPublicHandler = getPinnedShopPublicHandler;
+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 PinnedShopPublicHandler {
+    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 software.amazon.smithy.app#AppAPI.PinnedShopPublic. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new server_common_1.InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "PinnedShopPublic", this.serializer, this.operation, this.serializeFrameworkException, PinnedShopPublicServerInput.validate, this.validationCustomizer);
+    }
+}
+exports.PinnedShopPublicHandler = PinnedShopPublicHandler;

package/dist-cjs/server/operations/Plan.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanHandler = exports.getPlanHandler = exports.PlanSerializer = exports.PlanServerInput = 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 PlanServerInput;
+(function (PlanServerInput) {
+    PlanServerInput.validate = models_0_1.PlanGetInput.validate;
+})(PlanServerInput = exports.PlanServerInput || (exports.PlanServerInput = {}));
+class PlanSerializer {
+    constructor() {
+        this.serialize = Aws_restJson1_1.serializePlanResponse;
+        this.deserialize = Aws_restJson1_1.deserializePlanRequest;
+    }
+    isOperationError(error) {
+        const names = ["ValidationException", "RuntimeError"];
+        return names.includes(error.name);
+    }
+    ;
+    serializeError(error, ctx) {
+        switch (error.name) {
+            case "ValidationException": {
+                return (0, Aws_restJson1_1.serializeValidationExceptionError)(error, ctx);
+            }
+            case "RuntimeError": {
+                return (0, Aws_restJson1_1.serializeRuntimeErrorError)(error, ctx);
+            }
+            default: {
+                throw error;
+            }
+        }
+    }
+}
+exports.PlanSerializer = PlanSerializer;
+const getPlanHandler = (operation) => {
+    const mux = new server_common_1.httpbinding.HttpBindingMux([
+        new server_common_1.httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "plan" },
+        ], [
+            { type: 'query', key: "org_id" },
+        ], { service: "AppAPI", operation: "Plan" }),
+    ]);
+    const customizer = (ctx, failures) => {
+        if (!failures) {
+            return undefined;
+        }
+        return {
+            name: "ValidationException",
+            $fault: "client",
+            message: (0, server_common_1.generateValidationSummary)(failures),
+            fieldList: failures.map(failure => ({
+                path: failure.path,
+                message: (0, server_common_1.generateValidationMessage)(failure)
+            }))
+        };
+    };
+    return new PlanHandler(operation, mux, new PlanSerializer(), Aws_restJson1_1.serializeFrameworkException, customizer);
+};
+exports.getPlanHandler = getPlanHandler;
+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 PlanHandler {
+    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 software.amazon.smithy.app#AppAPI.Plan. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new server_common_1.InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "Plan", this.serializer, this.operation, this.serializeFrameworkException, PlanServerInput.validate, this.validationCustomizer);
+    }
+}
+exports.PlanHandler = PlanHandler;

package/dist-cjs/server/operations/PlanPublic.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanPublicHandler = exports.getPlanPublicHandler = exports.PlanPublicSerializer = exports.PlanPublicServerInput = 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 PlanPublicServerInput;
+(function (PlanPublicServerInput) {
+    PlanPublicServerInput.validate = models_0_1.PlanGetInput.validate;
+})(PlanPublicServerInput = exports.PlanPublicServerInput || (exports.PlanPublicServerInput = {}));
+class PlanPublicSerializer {
+    constructor() {
+        this.serialize = Aws_restJson1_1.serializePlanPublicResponse;
+        this.deserialize = Aws_restJson1_1.deserializePlanPublicRequest;
+    }
+    isOperationError(error) {
+        const names = ["ValidationException", "RuntimeError"];
+        return names.includes(error.name);
+    }
+    ;
+    serializeError(error, ctx) {
+        switch (error.name) {
+            case "ValidationException": {
+                return (0, Aws_restJson1_1.serializeValidationExceptionError)(error, ctx);
+            }
+            case "RuntimeError": {
+                return (0, Aws_restJson1_1.serializeRuntimeErrorError)(error, ctx);
+            }
+            default: {
+                throw error;
+            }
+        }
+    }
+}
+exports.PlanPublicSerializer = PlanPublicSerializer;
+const getPlanPublicHandler = (operation) => {
+    const mux = new server_common_1.httpbinding.HttpBindingMux([
+        new server_common_1.httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "public" },
+            { type: 'path_literal', value: "plan" },
+        ], [
+            { type: 'query', key: "org_id" },
+        ], { service: "AppAPI", operation: "PlanPublic" }),
+    ]);
+    const customizer = (ctx, failures) => {
+        if (!failures) {
+            return undefined;
+        }
+        return {
+            name: "ValidationException",
+            $fault: "client",
+            message: (0, server_common_1.generateValidationSummary)(failures),
+            fieldList: failures.map(failure => ({
+                path: failure.path,
+                message: (0, server_common_1.generateValidationMessage)(failure)
+            }))
+        };
+    };
+    return new PlanPublicHandler(operation, mux, new PlanPublicSerializer(), Aws_restJson1_1.serializeFrameworkException, customizer);
+};
+exports.getPlanPublicHandler = getPlanPublicHandler;
+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 PlanPublicHandler {
+    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 software.amazon.smithy.app#AppAPI.PlanPublic. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new server_common_1.InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "PlanPublic", this.serializer, this.operation, this.serializeFrameworkException, PlanPublicServerInput.validate, this.validationCustomizer);
+    }
+}
+exports.PlanPublicHandler = PlanPublicHandler;

package/dist-cjs/server/operations/Plans.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlansHandler = exports.getPlansHandler = exports.PlansSerializer = exports.PlansServerInput = 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 PlansServerInput;
+(function (PlansServerInput) {
+    PlansServerInput.validate = models_0_1.PlansListInput.validate;
+})(PlansServerInput = exports.PlansServerInput || (exports.PlansServerInput = {}));
+class PlansSerializer {
+    constructor() {
+        this.serialize = Aws_restJson1_1.serializePlansResponse;
+        this.deserialize = Aws_restJson1_1.deserializePlansRequest;
+    }
+    isOperationError(error) {
+        const names = ["ValidationException", "RuntimeError"];
+        return names.includes(error.name);
+    }
+    ;
+    serializeError(error, ctx) {
+        switch (error.name) {
+            case "ValidationException": {
+                return (0, Aws_restJson1_1.serializeValidationExceptionError)(error, ctx);
+            }
+            case "RuntimeError": {
+                return (0, Aws_restJson1_1.serializeRuntimeErrorError)(error, ctx);
+            }
+            default: {
+                throw error;
+            }
+        }
+    }
+}
+exports.PlansSerializer = PlansSerializer;
+const getPlansHandler = (operation) => {
+    const mux = new server_common_1.httpbinding.HttpBindingMux([
+        new server_common_1.httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "plans" },
+        ], [
+            { type: 'query', key: "lat" },
+            { type: 'query', key: "lon" },
+        ], { service: "AppAPI", operation: "Plans" }),
+    ]);
+    const customizer = (ctx, failures) => {
+        if (!failures) {
+            return undefined;
+        }
+        return {
+            name: "ValidationException",
+            $fault: "client",
+            message: (0, server_common_1.generateValidationSummary)(failures),
+            fieldList: failures.map(failure => ({
+                path: failure.path,
+                message: (0, server_common_1.generateValidationMessage)(failure)
+            }))
+        };
+    };
+    return new PlansHandler(operation, mux, new PlansSerializer(), Aws_restJson1_1.serializeFrameworkException, customizer);
+};
+exports.getPlansHandler = getPlansHandler;
+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 PlansHandler {
+    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 software.amazon.smithy.app#AppAPI.Plans. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new server_common_1.InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "Plans", this.serializer, this.operation, this.serializeFrameworkException, PlansServerInput.validate, this.validationCustomizer);
+    }
+}
+exports.PlansHandler = PlansHandler;

package/dist-cjs/server/operations/PopularShops.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PopularShopsHandler = exports.getPopularShopsHandler = exports.PopularShopsSerializer = exports.PopularShopsServerInput = 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 PopularShopsServerInput;
+(function (PopularShopsServerInput) {
+    PopularShopsServerInput.validate = models_0_1.ShopListInput.validate;
+})(PopularShopsServerInput = exports.PopularShopsServerInput || (exports.PopularShopsServerInput = {}));
+class PopularShopsSerializer {
+    constructor() {
+        this.serialize = Aws_restJson1_1.serializePopularShopsResponse;
+        this.deserialize = Aws_restJson1_1.deserializePopularShopsRequest;
+    }
+    isOperationError(error) {
+        const names = ["ValidationException", "RuntimeError"];
+        return names.includes(error.name);
+    }
+    ;
+    serializeError(error, ctx) {
+        switch (error.name) {
+            case "ValidationException": {
+                return (0, Aws_restJson1_1.serializeValidationExceptionError)(error, ctx);
+            }
+            case "RuntimeError": {
+                return (0, Aws_restJson1_1.serializeRuntimeErrorError)(error, ctx);
+            }
+            default: {
+                throw error;
+            }
+        }
+    }
+}
+exports.PopularShopsSerializer = PopularShopsSerializer;
+const getPopularShopsHandler = (operation) => {
+    const mux = new server_common_1.httpbinding.HttpBindingMux([
+        new server_common_1.httpbinding.UriSpec('GET', [
+            { type: 'path_literal', value: "shops" },
+            { type: 'path_literal', value: "popular" },
+        ], [], { service: "AppAPI", operation: "PopularShops" }),
+    ]);
+    const customizer = (ctx, failures) => {
+        if (!failures) {
+            return undefined;
+        }
+        return {
+            name: "ValidationException",
+            $fault: "client",
+            message: (0, server_common_1.generateValidationSummary)(failures),
+            fieldList: failures.map(failure => ({
+                path: failure.path,
+                message: (0, server_common_1.generateValidationMessage)(failure)
+            }))
+        };
+    };
+    return new PopularShopsHandler(operation, mux, new PopularShopsSerializer(), Aws_restJson1_1.serializeFrameworkException, customizer);
+};
+exports.getPopularShopsHandler = getPopularShopsHandler;
+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 PopularShopsHandler {
+    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 software.amazon.smithy.app#AppAPI.PopularShops. This indicates a misconfiguration.');
+            return this.serializeFrameworkException(new server_common_1.InternalFailureException(), serdeContextBase);
+        }
+        return handle(request, context, "PopularShops", this.serializer, this.operation, this.serializeFrameworkException, PopularShopsServerInput.validate, this.validationCustomizer);
+    }
+}
+exports.PopularShopsHandler = PopularShopsHandler;