@sparkrewards/sra-sdk 0.0.1

package/dist-es/protocols/Aws_restJson1.js

@@ -0,0 +1,2878 @@
+import { parseJsonBody as parseBody, } from "@aws-sdk/core";
+import { NotAcceptableException as __NotAcceptableException, SerializationException as __SerializationException, UnsupportedMediaTypeException as __UnsupportedMediaTypeException, acceptMatches as __acceptMatches, } from "@aws-smithy/server-common";
+import { HttpResponse as __HttpResponse, } from "@smithy/protocol-http";
+import { expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, serializeFloat as __serializeFloat, strictParseDouble as __strictParseDouble, strictParseInt32 as __strictParseInt32, collectBody, map, take, } from "@smithy/smithy-client";
+import { calculateBodyLength } from "@smithy/util-body-length-node";
+export const deserializeDeleteUserRequest = 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({});
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeFavoritePlansRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["page"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["page"])) {
+                if (query["page"].length === 1) {
+                    queryValue = query["page"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["page"];
+            }
+            contents.page = __strictParseInt32(queryValue);
+        }
+        if (query["limit"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["limit"])) {
+                if (query["limit"].length === 1) {
+                    queryValue = query["limit"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["limit"];
+            }
+            contents.limit = __strictParseInt32(queryValue);
+        }
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeFavoriteShopsRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+        if (query["page"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["page"])) {
+                if (query["page"].length === 1) {
+                    queryValue = query["page"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["page"];
+            }
+            contents.page = __strictParseInt32(queryValue);
+        }
+        if (query["filters"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["filters"])) {
+                if (query["filters"].length === 1) {
+                    queryValue = query["filters"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["filters"];
+            }
+            contents.filters = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeGetShopRequest = 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 pathRegex = new RegExp("/shops/shop/(?<shop_id>[^/]+)");
+    const parsedPath = output.path.match(pathRegex);
+    if (parsedPath?.groups !== undefined) {
+        contents.shop_id = decodeURIComponent(parsedPath.groups.shop_id);
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeGetShopPublicRequest = 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 pathRegex = new RegExp("/public/shops/shop/(?<shop_id>[^/]+)");
+    const parsedPath = output.path.match(pathRegex);
+    if (parsedPath?.groups !== undefined) {
+        contents.shop_id = decodeURIComponent(parsedPath.groups.shop_id);
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeGetUserRequest = 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({});
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeLikeOrgRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["org_id"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["org_id"])) {
+                if (query["org_id"].length === 1) {
+                    queryValue = query["org_id"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["org_id"];
+            }
+            contents.org_id = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeNearbyShopsRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+        if (query["page"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["page"])) {
+                if (query["page"].length === 1) {
+                    queryValue = query["page"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["page"];
+            }
+            contents.page = __strictParseInt32(queryValue);
+        }
+        if (query["filters"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["filters"])) {
+                if (query["filters"].length === 1) {
+                    queryValue = query["filters"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["filters"];
+            }
+            contents.filters = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeNearbyShopsPublicRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+        if (query["page"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["page"])) {
+                if (query["page"].length === 1) {
+                    queryValue = query["page"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["page"];
+            }
+            contents.page = __strictParseInt32(queryValue);
+        }
+        if (query["filters"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["filters"])) {
+                if (query["filters"].length === 1) {
+                    queryValue = query["filters"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["filters"];
+            }
+            contents.filters = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeNearestShopRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["shop_name"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["shop_name"])) {
+                if (query["shop_name"].length === 1) {
+                    queryValue = query["shop_name"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["shop_name"];
+            }
+            contents.shop_name = queryValue;
+        }
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeOnboardUserRequest = 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({});
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializePinnedShopRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["shop_id"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["shop_id"])) {
+                if (query["shop_id"].length === 1) {
+                    queryValue = query["shop_id"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["shop_id"];
+            }
+            contents.shop_id = queryValue;
+        }
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializePinnedShopPublicRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["shop_id"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["shop_id"])) {
+                if (query["shop_id"].length === 1) {
+                    queryValue = query["shop_id"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["shop_id"];
+            }
+            contents.shop_id = queryValue;
+        }
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializePlanRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["org_id"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["org_id"])) {
+                if (query["org_id"].length === 1) {
+                    queryValue = query["org_id"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["org_id"];
+            }
+            contents.org_id = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializePlanPublicRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["org_id"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["org_id"])) {
+                if (query["org_id"].length === 1) {
+                    queryValue = query["org_id"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["org_id"];
+            }
+            contents.org_id = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializePlansRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["page"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["page"])) {
+                if (query["page"].length === 1) {
+                    queryValue = query["page"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["page"];
+            }
+            contents.page = __strictParseInt32(queryValue);
+        }
+        if (query["limit"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["limit"])) {
+                if (query["limit"].length === 1) {
+                    queryValue = query["limit"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["limit"];
+            }
+            contents.limit = __strictParseInt32(queryValue);
+        }
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializePopularShopsRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+        if (query["page"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["page"])) {
+                if (query["page"].length === 1) {
+                    queryValue = query["page"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["page"];
+            }
+            contents.page = __strictParseInt32(queryValue);
+        }
+        if (query["filters"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["filters"])) {
+                if (query["filters"].length === 1) {
+                    queryValue = query["filters"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["filters"];
+            }
+            contents.filters = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializePopularShopsPublicRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+        if (query["page"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["page"])) {
+                if (query["page"].length === 1) {
+                    queryValue = query["page"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["page"];
+            }
+            contents.page = __strictParseInt32(queryValue);
+        }
+        if (query["filters"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["filters"])) {
+                if (query["filters"].length === 1) {
+                    queryValue = query["filters"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["filters"];
+            }
+            contents.filters = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeRadiusShopsRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+        if (query["page"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["page"])) {
+                if (query["page"].length === 1) {
+                    queryValue = query["page"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["page"];
+            }
+            contents.page = __strictParseInt32(queryValue);
+        }
+        if (query["filters"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["filters"])) {
+                if (query["filters"].length === 1) {
+                    queryValue = query["filters"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["filters"];
+            }
+            contents.filters = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeRecordVisitRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["shop_id"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["shop_id"])) {
+                if (query["shop_id"].length === 1) {
+                    queryValue = query["shop_id"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["shop_id"];
+            }
+            contents.shop_id = queryValue;
+        }
+        if (query["timestamp"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["timestamp"])) {
+                if (query["timestamp"].length === 1) {
+                    queryValue = query["timestamp"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["timestamp"];
+            }
+            contents.timestamp = queryValue;
+        }
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeRedeemFirstTimeRewardRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["org_id"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["org_id"])) {
+                if (query["org_id"].length === 1) {
+                    queryValue = query["org_id"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["org_id"];
+            }
+            contents.org_id = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeRedeemPointRewardRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["org_id"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["org_id"])) {
+                if (query["org_id"].length === 1) {
+                    queryValue = query["org_id"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["org_id"];
+            }
+            contents.org_id = queryValue;
+        }
+        if (query["reward_id"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["reward_id"])) {
+                if (query["reward_id"].length === 1) {
+                    queryValue = query["reward_id"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["reward_id"];
+            }
+            contents.reward_id = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeRedeemVisitRewardRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["reward_id"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["reward_id"])) {
+                if (query["reward_id"].length === 1) {
+                    queryValue = query["reward_id"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["reward_id"];
+            }
+            contents.reward_id = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeSearchShopsPublicRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["q"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["q"])) {
+                if (query["q"].length === 1) {
+                    queryValue = query["q"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["q"];
+            }
+            contents.q = queryValue;
+        }
+        if (query["limit"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["limit"])) {
+                if (query["limit"].length === 1) {
+                    queryValue = query["limit"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["limit"];
+            }
+            contents.limit = __strictParseInt32(queryValue);
+        }
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+        if (query["page"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["page"])) {
+                if (query["page"].length === 1) {
+                    queryValue = query["page"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["page"];
+            }
+            contents.page = __strictParseInt32(queryValue);
+        }
+        if (query["filters"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["filters"])) {
+                if (query["filters"].length === 1) {
+                    queryValue = query["filters"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["filters"];
+            }
+            contents.filters = queryValue;
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeSearchSuggestionRequest = 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 query = output.query;
+    if (query != null) {
+        if (query["q"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["q"])) {
+                if (query["q"].length === 1) {
+                    queryValue = query["q"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["q"];
+            }
+            contents.q = queryValue;
+        }
+        if (query["limit"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["limit"])) {
+                if (query["limit"].length === 1) {
+                    queryValue = query["limit"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["limit"];
+            }
+            contents.limit = __strictParseInt32(queryValue);
+        }
+        if (query["lat"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lat"])) {
+                if (query["lat"].length === 1) {
+                    queryValue = query["lat"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lat"];
+            }
+            contents.lat = __strictParseDouble(queryValue);
+        }
+        if (query["lon"] !== undefined) {
+            let queryValue;
+            if (Array.isArray(query["lon"])) {
+                if (query["lon"].length === 1) {
+                    queryValue = query["lon"][0];
+                }
+                else {
+                    throw new __SerializationException();
+                }
+            }
+            else {
+                queryValue = query["lon"];
+            }
+            contents.lon = __strictParseDouble(queryValue);
+        }
+    }
+    await collectBody(output.body, context);
+    return contents;
+};
+export const deserializeUpdateUserRequest = 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, {
+        'fullname': _ => de_UserFullnameUpdate(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const serializeDeleteUserResponse = 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, {
+        'message': [],
+    }));
+    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 serializeFavoritePlansResponse = 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, {
+        'count': [],
+        'pagination': _ => se_PaginationInfo(_, context),
+        'value': _ => se_GroupedPlanList(_, 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 serializeFavoriteShopsResponse = 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, {
+        'count': [],
+        'message': [],
+        'pagination': _ => se_PaginationInfo(_, context),
+        'value': _ => se_EnrichedShopList(_, 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 serializeGetShopResponse = 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, {
+        'active': [],
+        'banner': [],
+        'country_code': [],
+        'description': [],
+        'id': [],
+        'latitude': _ => __serializeFloat(_),
+        'location': _ => se_LocationDetails(_, context),
+        'logo': [],
+        'longitude': _ => __serializeFloat(_),
+        'menu': [],
+        'org_id': [],
+        'org_name': [],
+        'phone_number': [],
+        'preview': [],
+        'sent_setup': [],
+        'setup': [],
+        'shop_hours': _ => se_ShopHoursList(_, context),
+        'shop_name': [],
+        'tags': _ => se_StringList(_, 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 serializeGetShopPublicResponse = 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, {
+        'active': [],
+        'banner': [],
+        'country_code': [],
+        'description': [],
+        'id': [],
+        'latitude': _ => __serializeFloat(_),
+        'location': _ => se_LocationDetails(_, context),
+        'logo': [],
+        'longitude': _ => __serializeFloat(_),
+        'menu': [],
+        'org_id': [],
+        'org_name': [],
+        'phone_number': [],
+        'preview': [],
+        'sent_setup': [],
+        'setup': [],
+        'shop_hours': _ => se_ShopHoursList(_, context),
+        'shop_name': [],
+        'tags': _ => se_StringList(_, 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 serializeGetUserResponse = 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, {
+        'message': [],
+        'user': _ => se_User(_, 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 serializeLikeOrgResponse = 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, {
+        'liked': [],
+        'message': [],
+    }));
+    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 serializeNearbyShopsResponse = 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, {
+        'count': [],
+        'message': [],
+        'pagination': _ => se_PaginationInfo(_, context),
+        'value': _ => se_EnrichedShopList(_, 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 serializeNearbyShopsPublicResponse = 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, {
+        'count': [],
+        'message': [],
+        'pagination': _ => se_PaginationInfo(_, context),
+        'value': _ => se_EnrichedShopList(_, 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 serializeNearestShopResponse = 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, {
+        'distance': [],
+        'favorite': [],
+        'location': _ => se_LocationDetails(_, context),
+        'logo': [],
+        'name': [],
+        'org_id': [],
+        'preview': [],
+        'shop_hours': _ => se_ShopHoursList(_, context),
+        'shop_id': [],
+        'tags': _ => se_StringList(_, 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 serializeOnboardUserResponse = 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, {
+        'message': [],
+        'user': _ => se_User(_, 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 serializePinnedShopResponse = 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, {
+        'distance': [],
+        'favorite': [],
+        'location': _ => se_LocationDetails(_, context),
+        'logo': [],
+        'name': [],
+        'org_id': [],
+        'preview': [],
+        'shop_hours': _ => se_ShopHoursList(_, context),
+        'shop_id': [],
+        'tags': _ => se_StringList(_, 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 serializePinnedShopPublicResponse = 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, {
+        'distance': [],
+        'favorite': [],
+        'location': _ => se_LocationDetails(_, context),
+        'logo': [],
+        'name': [],
+        'org_id': [],
+        'preview': [],
+        'shop_hours': _ => se_ShopHoursList(_, context),
+        'shop_id': [],
+        'tags': _ => se_StringList(_, 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 serializePlanResponse = 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, {
+        'active': [],
+        'favorite': [],
+        'firstPlan': [],
+        'first_time_reward': _ => se_FirstTimeReward(_, context),
+        'id': [],
+        'min_spend': [],
+        'name': [],
+        'organization_id': [],
+        'points': [],
+        'points_active': [],
+        'redeemableRewards': _ => se_RewardList(_, context),
+        'reward_plan': _ => se_RewardPlan(_, context),
+        'visits': [],
+        'visits_active': [],
+    }));
+    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 serializePlanPublicResponse = 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, {
+        'active': [],
+        'favorite': [],
+        'firstPlan': [],
+        'first_time_reward': _ => se_FirstTimeReward(_, context),
+        'id': [],
+        'min_spend': [],
+        'name': [],
+        'organization_id': [],
+        'points': [],
+        'points_active': [],
+        'redeemableRewards': _ => se_RewardList(_, context),
+        'reward_plan': _ => se_RewardPlan(_, context),
+        'visits': [],
+        'visits_active': [],
+    }));
+    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 serializePlansResponse = 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, {
+        'count': [],
+        'pagination': _ => se_PaginationInfo(_, context),
+        'value': _ => se_GroupedPlanList(_, 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 serializePopularShopsResponse = 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, {
+        'count': [],
+        'message': [],
+        'pagination': _ => se_PaginationInfo(_, context),
+        'value': _ => se_EnrichedShopList(_, 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 serializePopularShopsPublicResponse = 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, {
+        'count': [],
+        'message': [],
+        'pagination': _ => se_PaginationInfo(_, context),
+        'value': _ => se_EnrichedShopList(_, 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 serializeRadiusShopsResponse = 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, {
+        'count': [],
+        'message': [],
+        'value': _ => se_ShopLocationList(_, 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 serializeRecordVisitResponse = 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, {
+        'message': [],
+        'reason': [],
+        'success': [],
+        'visitId': [],
+    }));
+    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 serializeRedeemFirstTimeRewardResponse = 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, {
+        'message': [],
+        'redeemed': [],
+    }));
+    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 serializeRedeemPointRewardResponse = 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, {
+        'message': [],
+        'pointsUsed': [],
+        'redeemed': [],
+        'remainingPoints': [],
+    }));
+    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 serializeRedeemVisitRewardResponse = 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, {
+        'message': [],
+        'redeemed': [],
+    }));
+    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 serializeSearchShopsPublicResponse = 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, {
+        'count': [],
+        'message': [],
+        'pagination': _ => se_PaginationInfo(_, context),
+        'value': _ => se_EnrichedShopList(_, 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 serializeSearchSuggestionResponse = 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, {
+        'value': _ => se_SearchSuggestionList(_, 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 serializeUpdateUserResponse = 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, {
+        'message': [],
+        'user': _ => se_User(_, 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 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 serializeValidationExceptionError = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    const statusCode = 400;
+    let headers = map({}, isSerializableHeaderValue, {
+        'x-amzn-errortype': "ValidationException",
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'fieldList': _ => se_ValidationExceptionFieldList(_, context),
+        'message': [],
+    }));
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeInvalidOperationErrorError = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    const statusCode = 400;
+    let headers = map({}, isSerializableHeaderValue, {
+        'x-amzn-errortype': "InvalidOperationError",
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'message': [],
+    }));
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeNotFoundErrorError = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    const statusCode = 404;
+    let headers = map({}, isSerializableHeaderValue, {
+        'x-amzn-errortype': "NotFoundError",
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'message': [],
+    }));
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+export const serializeRuntimeErrorError = async (input, ctx) => {
+    const context = {
+        ...ctx,
+        endpoint: () => Promise.resolve({
+            protocol: '',
+            hostname: '',
+            path: '',
+        }),
+    };
+    const statusCode = 500;
+    let headers = map({}, isSerializableHeaderValue, {
+        'x-amzn-errortype': "RuntimeError",
+        'content-type': 'application/json',
+    });
+    let body;
+    body = JSON.stringify(take(input, {
+        'message': [],
+    }));
+    return new __HttpResponse({
+        headers,
+        body,
+        statusCode,
+    });
+};
+const se_ValidationExceptionField = (input, context) => {
+    return take(input, {
+        'message': [],
+        'path': [],
+    });
+};
+const se_ValidationExceptionFieldList = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ValidationExceptionField(entry, context);
+    });
+};
+const se_EnrichedShop = (input, context) => {
+    return take(input, {
+        'distance': [],
+        'favorite': [],
+        'location': _ => se_LocationDetails(_, context),
+        'logo': [],
+        'name': [],
+        'org_id': [],
+        'preview': [],
+        'shop_hours': _ => se_ShopHoursList(_, context),
+        'shop_id': [],
+        'tags': _ => se_StringList(_, context),
+    });
+};
+const se_EnrichedShopList = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_EnrichedShop(entry, context);
+    });
+};
+const se_FirstTimeReward = (input, context) => {
+    return take(input, {
+        'active': [],
+        'description': [],
+    });
+};
+const se_GroupedPlan = (input, context) => {
+    return take(input, {
+        'active': [],
+        'banner': [],
+        'favorite': [],
+        'id': [],
+        'logo': [],
+        'name': [],
+        'num_redeemableRewards': [],
+        'org_id': [],
+        'points': [],
+        'points_active': [],
+        'redeemableRewards': _ => se_RewardList(_, context),
+        'reward_plan': _ => se_RewardPlan(_, context),
+        'shop_id': [],
+        'visits': [],
+        'visits_active': [],
+    });
+};
+const se_GroupedPlanList = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_GroupedPlan(entry, context);
+    });
+};
+const se_LocationDetails = (input, context) => {
+    return take(input, {
+        'address': [],
+        'city': [],
+        'state': [],
+        'zipcode': [],
+    });
+};
+const se_PaginationInfo = (input, context) => {
+    return take(input, {
+        'currentPage': [],
+        'hasMore': [],
+        'limit': [],
+        'nextPage': [],
+    });
+};
+const se_PointsRewardOption = (input, context) => {
+    return take(input, {
+        'id': [],
+        'points': [],
+        'reward': [],
+    });
+};
+const se_PointsRewardOptionList = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_PointsRewardOption(entry, context);
+    });
+};
+const se_Reward = (input, context) => {
+    return take(input, {
+        'id': [],
+        'reward_id': [],
+    });
+};
+const se_RewardList = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_Reward(entry, context);
+    });
+};
+const se_RewardPlan = (input, context) => {
+    return take(input, {
+        'points': _ => se_PointsRewardOptionList(_, context),
+        'visits': _ => se_VisitRewardProps(_, context),
+    });
+};
+const se_SearchSuggestionItem = (input, context) => {
+    return take(input, {
+        'distance': __serializeFloat,
+        'favorite': [],
+        'organization_id': [],
+        'search_name': [],
+        'shop_id': [],
+    });
+};
+const se_SearchSuggestionList = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_SearchSuggestionItem(entry, context);
+    });
+};
+const se_ShopHoursItem = (input, context) => {
+    return take(input, {
+        'close': [],
+        'day': [],
+        'open': [],
+    });
+};
+const se_ShopHoursList = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ShopHoursItem(entry, context);
+    });
+};
+const se_ShopLocation = (input, context) => {
+    return take(input, {
+        'id': [],
+        'latitude': __serializeFloat,
+        'longitude': __serializeFloat,
+    });
+};
+const se_ShopLocationList = (input, context) => {
+    return input.filter((e) => e != null).map(entry => {
+        return se_ShopLocation(entry, context);
+    });
+};
+const se_StringList = (input, context) => {
+    return input.filter((e) => e != null);
+};
+const se_Tier = (input, context) => {
+    return take(input, {
+        'id': [],
+        'rewards': _ => se_StringList(_, context),
+    });
+};
+const se_TierMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = se_Tier(value, context);
+        return acc;
+    }, {});
+};
+const se_User = (input, context) => {
+    return take(input, {
+        'birthdate': [],
+        'date_created': [],
+        'email': [],
+        'fraud_count': [],
+        'fullname': _ => se_UserFullname(_, context),
+        'id': [],
+        'newAccount': [],
+        'num_redeemableRewards': [],
+        'preferences': _ => se_UserPreferences(_, context),
+        'total_points': [],
+        'total_rewards': [],
+        'total_visits': [],
+    });
+};
+const se_UserFullname = (input, context) => {
+    return take(input, {
+        'firstName': [],
+        'lastName': [],
+    });
+};
+const se_UserPreferences = (input, context) => {
+    return take(input, {
+        'lightMode': [],
+    });
+};
+const se_VisitRewardProps = (input, context) => {
+    return take(input, {
+        'min_spend': [],
+        'tiers': _ => se_TierMap(_, context),
+    });
+};
+const de_UserFullnameUpdate = (output, context) => {
+    return take(output, {
+        'firstName': __expectString,
+        'lastName': __expectString,
+    });
+};
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then(body => context.utf8Encoder(body));
+const isSerializableHeaderValue = (value) => value !== undefined &&
+    value !== null &&
+    value !== "" &&
+    (!Object.getOwnPropertyNames(value).includes("length") ||
+        value.length != 0) &&
+    (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);