@sparkrewards/sra-sdk 0.0.1

package/dist-types/openapi.d.ts

@@ -0,0 +1,7 @@
+import openApiJson from './openapi.json';
+/**
+ * OpenAPI 3.1.0 specification for the AppAPI service
+ * Generated from Smithy model
+ */
+export declare const OpenApiJSON: typeof openApiJson;
+export default OpenApiJSON;

package/dist-types/protocols/Aws_restJson1.d.ts

@@ -0,0 +1,87 @@
+import { InvalidOperationError, NotFoundError, RuntimeError, ValidationException } from "../models/models_0";
+import { DeleteUserServerInput, DeleteUserServerOutput } from "../server/operations/DeleteUser";
+import { FavoritePlansServerInput, FavoritePlansServerOutput } from "../server/operations/FavoritePlans";
+import { FavoriteShopsServerInput, FavoriteShopsServerOutput } from "../server/operations/FavoriteShops";
+import { GetShopServerInput, GetShopServerOutput } from "../server/operations/GetShop";
+import { GetShopPublicServerInput, GetShopPublicServerOutput } from "../server/operations/GetShopPublic";
+import { GetUserServerInput, GetUserServerOutput } from "../server/operations/GetUser";
+import { LikeOrgServerInput, LikeOrgServerOutput } from "../server/operations/LikeOrg";
+import { NearbyShopsServerInput, NearbyShopsServerOutput } from "../server/operations/NearbyShops";
+import { NearbyShopsPublicServerInput, NearbyShopsPublicServerOutput } from "../server/operations/NearbyShopsPublic";
+import { NearestShopServerInput, NearestShopServerOutput } from "../server/operations/NearestShop";
+import { OnboardUserServerInput, OnboardUserServerOutput } from "../server/operations/OnboardUser";
+import { PinnedShopServerInput, PinnedShopServerOutput } from "../server/operations/PinnedShop";
+import { PinnedShopPublicServerInput, PinnedShopPublicServerOutput } from "../server/operations/PinnedShopPublic";
+import { PlanServerInput, PlanServerOutput } from "../server/operations/Plan";
+import { PlanPublicServerInput, PlanPublicServerOutput } from "../server/operations/PlanPublic";
+import { PlansServerInput, PlansServerOutput } from "../server/operations/Plans";
+import { PopularShopsServerInput, PopularShopsServerOutput } from "../server/operations/PopularShops";
+import { PopularShopsPublicServerInput, PopularShopsPublicServerOutput } from "../server/operations/PopularShopsPublic";
+import { RadiusShopsServerInput, RadiusShopsServerOutput } from "../server/operations/RadiusShops";
+import { RecordVisitServerInput, RecordVisitServerOutput } from "../server/operations/RecordVisit";
+import { RedeemFirstTimeRewardServerInput, RedeemFirstTimeRewardServerOutput } from "../server/operations/RedeemFirstTimeReward";
+import { RedeemPointRewardServerInput, RedeemPointRewardServerOutput } from "../server/operations/RedeemPointReward";
+import { RedeemVisitRewardServerInput, RedeemVisitRewardServerOutput } from "../server/operations/RedeemVisitReward";
+import { SearchShopsPublicServerInput, SearchShopsPublicServerOutput } from "../server/operations/SearchShopsPublic";
+import { SearchSuggestionServerInput, SearchSuggestionServerOutput } from "../server/operations/SearchSuggestion";
+import { UpdateUserServerInput, UpdateUserServerOutput } from "../server/operations/UpdateUser";
+import { ServerSerdeContext, SmithyFrameworkException as __SmithyFrameworkException } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+import { SerdeContext as __SerdeContext } from "@smithy/types";
+export declare const deserializeDeleteUserRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<DeleteUserServerInput>;
+export declare const deserializeFavoritePlansRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<FavoritePlansServerInput>;
+export declare const deserializeFavoriteShopsRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<FavoriteShopsServerInput>;
+export declare const deserializeGetShopRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<GetShopServerInput>;
+export declare const deserializeGetShopPublicRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<GetShopPublicServerInput>;
+export declare const deserializeGetUserRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<GetUserServerInput>;
+export declare const deserializeLikeOrgRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<LikeOrgServerInput>;
+export declare const deserializeNearbyShopsRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<NearbyShopsServerInput>;
+export declare const deserializeNearbyShopsPublicRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<NearbyShopsPublicServerInput>;
+export declare const deserializeNearestShopRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<NearestShopServerInput>;
+export declare const deserializeOnboardUserRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<OnboardUserServerInput>;
+export declare const deserializePinnedShopRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<PinnedShopServerInput>;
+export declare const deserializePinnedShopPublicRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<PinnedShopPublicServerInput>;
+export declare const deserializePlanRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<PlanServerInput>;
+export declare const deserializePlanPublicRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<PlanPublicServerInput>;
+export declare const deserializePlansRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<PlansServerInput>;
+export declare const deserializePopularShopsRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<PopularShopsServerInput>;
+export declare const deserializePopularShopsPublicRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<PopularShopsPublicServerInput>;
+export declare const deserializeRadiusShopsRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<RadiusShopsServerInput>;
+export declare const deserializeRecordVisitRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<RecordVisitServerInput>;
+export declare const deserializeRedeemFirstTimeRewardRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<RedeemFirstTimeRewardServerInput>;
+export declare const deserializeRedeemPointRewardRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<RedeemPointRewardServerInput>;
+export declare const deserializeRedeemVisitRewardRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<RedeemVisitRewardServerInput>;
+export declare const deserializeSearchShopsPublicRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<SearchShopsPublicServerInput>;
+export declare const deserializeSearchSuggestionRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<SearchSuggestionServerInput>;
+export declare const deserializeUpdateUserRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<UpdateUserServerInput>;
+export declare const serializeDeleteUserResponse: (input: DeleteUserServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeFavoritePlansResponse: (input: FavoritePlansServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeFavoriteShopsResponse: (input: FavoriteShopsServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeGetShopResponse: (input: GetShopServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeGetShopPublicResponse: (input: GetShopPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeGetUserResponse: (input: GetUserServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeLikeOrgResponse: (input: LikeOrgServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeNearbyShopsResponse: (input: NearbyShopsServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeNearbyShopsPublicResponse: (input: NearbyShopsPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeNearestShopResponse: (input: NearestShopServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeOnboardUserResponse: (input: OnboardUserServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializePinnedShopResponse: (input: PinnedShopServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializePinnedShopPublicResponse: (input: PinnedShopPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializePlanResponse: (input: PlanServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializePlanPublicResponse: (input: PlanPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializePlansResponse: (input: PlansServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializePopularShopsResponse: (input: PopularShopsServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializePopularShopsPublicResponse: (input: PopularShopsPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeRadiusShopsResponse: (input: RadiusShopsServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeRecordVisitResponse: (input: RecordVisitServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeRedeemFirstTimeRewardResponse: (input: RedeemFirstTimeRewardServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeRedeemPointRewardResponse: (input: RedeemPointRewardServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeRedeemVisitRewardResponse: (input: RedeemVisitRewardServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeSearchShopsPublicResponse: (input: SearchShopsPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeSearchSuggestionResponse: (input: SearchSuggestionServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeUpdateUserResponse: (input: UpdateUserServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeFrameworkException: (input: __SmithyFrameworkException, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeValidationExceptionError: (input: ValidationException, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeInvalidOperationErrorError: (input: InvalidOperationError, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeNotFoundErrorError: (input: NotFoundError, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeRuntimeErrorError: (input: RuntimeError, ctx: ServerSerdeContext) => Promise<__HttpResponse>;

package/dist-types/server/AppAPIService.d.ts

@@ -0,0 +1,76 @@
+import { DeleteUser } from "./operations/DeleteUser";
+import { FavoritePlans } from "./operations/FavoritePlans";
+import { FavoriteShops } from "./operations/FavoriteShops";
+import { GetShop } from "./operations/GetShop";
+import { GetShopPublic } from "./operations/GetShopPublic";
+import { GetUser } from "./operations/GetUser";
+import { LikeOrg } from "./operations/LikeOrg";
+import { NearbyShops } from "./operations/NearbyShops";
+import { NearbyShopsPublic } from "./operations/NearbyShopsPublic";
+import { NearestShop } from "./operations/NearestShop";
+import { OnboardUser } from "./operations/OnboardUser";
+import { PinnedShop } from "./operations/PinnedShop";
+import { PinnedShopPublic } from "./operations/PinnedShopPublic";
+import { Plan } from "./operations/Plan";
+import { PlanPublic } from "./operations/PlanPublic";
+import { Plans } from "./operations/Plans";
+import { PopularShops } from "./operations/PopularShops";
+import { PopularShopsPublic } from "./operations/PopularShopsPublic";
+import { RadiusShops } from "./operations/RadiusShops";
+import { RecordVisit } from "./operations/RecordVisit";
+import { RedeemFirstTimeReward } from "./operations/RedeemFirstTimeReward";
+import { RedeemPointReward } from "./operations/RedeemPointReward";
+import { RedeemVisitReward } from "./operations/RedeemVisitReward";
+import { SearchShopsPublic } from "./operations/SearchShopsPublic";
+import { SearchSuggestion } from "./operations/SearchSuggestion";
+import { UpdateUser } from "./operations/UpdateUser";
+import { Mux as __Mux, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceException as __ServiceException, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type AppAPIServiceOperations = "DeleteUser" | "FavoritePlans" | "FavoriteShops" | "GetShop" | "GetShopPublic" | "GetUser" | "LikeOrg" | "NearbyShops" | "NearbyShopsPublic" | "NearestShop" | "OnboardUser" | "PinnedShop" | "PinnedShopPublic" | "Plan" | "PlanPublic" | "Plans" | "PopularShops" | "PopularShopsPublic" | "RadiusShops" | "RecordVisit" | "RedeemFirstTimeReward" | "RedeemPointReward" | "RedeemVisitReward" | "SearchShopsPublic" | "SearchSuggestion" | "UpdateUser";
+export interface AppAPIService<Context> {
+    DeleteUser: DeleteUser<Context>;
+    FavoritePlans: FavoritePlans<Context>;
+    FavoriteShops: FavoriteShops<Context>;
+    GetShop: GetShop<Context>;
+    GetShopPublic: GetShopPublic<Context>;
+    GetUser: GetUser<Context>;
+    LikeOrg: LikeOrg<Context>;
+    NearbyShops: NearbyShops<Context>;
+    NearbyShopsPublic: NearbyShopsPublic<Context>;
+    NearestShop: NearestShop<Context>;
+    OnboardUser: OnboardUser<Context>;
+    PinnedShop: PinnedShop<Context>;
+    PinnedShopPublic: PinnedShopPublic<Context>;
+    Plan: Plan<Context>;
+    PlanPublic: PlanPublic<Context>;
+    Plans: Plans<Context>;
+    PopularShops: PopularShops<Context>;
+    PopularShopsPublic: PopularShopsPublic<Context>;
+    RadiusShops: RadiusShops<Context>;
+    RecordVisit: RecordVisit<Context>;
+    RedeemFirstTimeReward: RedeemFirstTimeReward<Context>;
+    RedeemPointReward: RedeemPointReward<Context>;
+    RedeemVisitReward: RedeemVisitReward<Context>;
+    SearchShopsPublic: SearchShopsPublic<Context>;
+    SearchSuggestion: SearchSuggestion<Context>;
+    UpdateUser: UpdateUser<Context>;
+}
+export declare class AppAPIServiceHandler<Context> implements __ServiceHandler<Context> {
+    private readonly service;
+    private readonly mux;
+    private readonly serializerFactory;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a AppAPIService handler.
+     * @param service The {@link AppAPIService} implementation that supplies the business logic for AppAPIService
+     * @param mux The {@link __Mux} that determines which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializerFactory A factory for an {@link __OperationSerializer} for each operation in AppAPIService that
+     *                          handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(service: AppAPIService<Context>, mux: __Mux<"AppAPI", AppAPIServiceOperations>, serializerFactory: <T extends AppAPIServiceOperations>(op: T) => __OperationSerializer<AppAPIService<Context>, T, __ServiceException>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<AppAPIServiceOperations>);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}
+export declare const getAppAPIServiceHandler: <Context>(service: AppAPIService<Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;

package/dist-types/server/index.d.ts

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

package/dist-types/server/operations/DeleteUser.d.ts

@@ -0,0 +1,41 @@
+import { DeleteUserInput, DeleteUserOutput, RuntimeError, ValidationException } from "../../models/models_0";
+import { AppAPIService } from "../AppAPIService";
+import { ServerSerdeContext, Mux as __Mux, Operation as __Operation, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer, ValidationFailure as __ValidationFailure } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type DeleteUser<Context> = __Operation<DeleteUserServerInput, DeleteUserServerOutput, Context>;
+export interface DeleteUserServerInput extends DeleteUserInput {
+}
+export declare namespace DeleteUserServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof DeleteUserInput.validate>[0]) => __ValidationFailure[];
+}
+export interface DeleteUserServerOutput extends DeleteUserOutput {
+}
+export type DeleteUserErrors = ValidationException | RuntimeError;
+export declare class DeleteUserSerializer implements __OperationSerializer<AppAPIService<any>, "DeleteUser", DeleteUserErrors> {
+    serialize: (input: DeleteUserServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<DeleteUserServerInput>;
+    isOperationError(error: any): error is DeleteUserErrors;
+    serializeError(error: DeleteUserErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getDeleteUserHandler: <Context>(operation: __Operation<DeleteUserServerInput, DeleteUserServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class DeleteUserHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a DeleteUser handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for DeleteUser
+     * @param mux The {@link __Mux} that verifies which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializer An {@link __OperationSerializer} for DeleteUser that
+     *                   handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(operation: __Operation<DeleteUserServerInput, DeleteUserServerOutput, Context>, mux: __Mux<"AppAPI", "DeleteUser">, serializer: __OperationSerializer<AppAPIService<Context>, "DeleteUser", DeleteUserErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"DeleteUser">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/FavoritePlans.d.ts

@@ -0,0 +1,41 @@
+import { PlansListInput, PlansOutput, RuntimeError, ValidationException } from "../../models/models_0";
+import { AppAPIService } from "../AppAPIService";
+import { ServerSerdeContext, Mux as __Mux, Operation as __Operation, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer, ValidationFailure as __ValidationFailure } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type FavoritePlans<Context> = __Operation<FavoritePlansServerInput, FavoritePlansServerOutput, Context>;
+export interface FavoritePlansServerInput extends PlansListInput {
+}
+export declare namespace FavoritePlansServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof PlansListInput.validate>[0]) => __ValidationFailure[];
+}
+export interface FavoritePlansServerOutput extends PlansOutput {
+}
+export type FavoritePlansErrors = ValidationException | RuntimeError;
+export declare class FavoritePlansSerializer implements __OperationSerializer<AppAPIService<any>, "FavoritePlans", FavoritePlansErrors> {
+    serialize: (input: FavoritePlansServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<FavoritePlansServerInput>;
+    isOperationError(error: any): error is FavoritePlansErrors;
+    serializeError(error: FavoritePlansErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getFavoritePlansHandler: <Context>(operation: __Operation<FavoritePlansServerInput, FavoritePlansServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class FavoritePlansHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a FavoritePlans handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for FavoritePlans
+     * @param mux The {@link __Mux} that verifies which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializer An {@link __OperationSerializer} for FavoritePlans that
+     *                   handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(operation: __Operation<FavoritePlansServerInput, FavoritePlansServerOutput, Context>, mux: __Mux<"AppAPI", "FavoritePlans">, serializer: __OperationSerializer<AppAPIService<Context>, "FavoritePlans", FavoritePlansErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"FavoritePlans">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/FavoriteShops.d.ts

@@ -0,0 +1,41 @@
+import { RuntimeError, ShopListInput, ShopListWithPaginationOutput, ValidationException } from "../../models/models_0";
+import { AppAPIService } from "../AppAPIService";
+import { ServerSerdeContext, Mux as __Mux, Operation as __Operation, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer, ValidationFailure as __ValidationFailure } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type FavoriteShops<Context> = __Operation<FavoriteShopsServerInput, FavoriteShopsServerOutput, Context>;
+export interface FavoriteShopsServerInput extends ShopListInput {
+}
+export declare namespace FavoriteShopsServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof ShopListInput.validate>[0]) => __ValidationFailure[];
+}
+export interface FavoriteShopsServerOutput extends ShopListWithPaginationOutput {
+}
+export type FavoriteShopsErrors = ValidationException | RuntimeError;
+export declare class FavoriteShopsSerializer implements __OperationSerializer<AppAPIService<any>, "FavoriteShops", FavoriteShopsErrors> {
+    serialize: (input: FavoriteShopsServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<FavoriteShopsServerInput>;
+    isOperationError(error: any): error is FavoriteShopsErrors;
+    serializeError(error: FavoriteShopsErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getFavoriteShopsHandler: <Context>(operation: __Operation<FavoriteShopsServerInput, FavoriteShopsServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class FavoriteShopsHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a FavoriteShops handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for FavoriteShops
+     * @param mux The {@link __Mux} that verifies which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializer An {@link __OperationSerializer} for FavoriteShops that
+     *                   handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(operation: __Operation<FavoriteShopsServerInput, FavoriteShopsServerOutput, Context>, mux: __Mux<"AppAPI", "FavoriteShops">, serializer: __OperationSerializer<AppAPIService<Context>, "FavoriteShops", FavoriteShopsErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"FavoriteShops">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/GetShop.d.ts

@@ -0,0 +1,41 @@
+import { GetShopInput, NotFoundError, RuntimeError, ShopDetails, ValidationException } from "../../models/models_0";
+import { AppAPIService } from "../AppAPIService";
+import { ServerSerdeContext, Mux as __Mux, Operation as __Operation, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer, ValidationFailure as __ValidationFailure } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type GetShop<Context> = __Operation<GetShopServerInput, GetShopServerOutput, Context>;
+export interface GetShopServerInput extends GetShopInput {
+}
+export declare namespace GetShopServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof GetShopInput.validate>[0]) => __ValidationFailure[];
+}
+export interface GetShopServerOutput extends ShopDetails {
+}
+export type GetShopErrors = ValidationException | RuntimeError | NotFoundError;
+export declare class GetShopSerializer implements __OperationSerializer<AppAPIService<any>, "GetShop", GetShopErrors> {
+    serialize: (input: GetShopServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<GetShopServerInput>;
+    isOperationError(error: any): error is GetShopErrors;
+    serializeError(error: GetShopErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getGetShopHandler: <Context>(operation: __Operation<GetShopServerInput, GetShopServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class GetShopHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a GetShop handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for GetShop
+     * @param mux The {@link __Mux} that verifies which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializer An {@link __OperationSerializer} for GetShop that
+     *                   handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(operation: __Operation<GetShopServerInput, GetShopServerOutput, Context>, mux: __Mux<"AppAPI", "GetShop">, serializer: __OperationSerializer<AppAPIService<Context>, "GetShop", GetShopErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"GetShop">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/GetShopPublic.d.ts

@@ -0,0 +1,41 @@
+import { GetShopInput, NotFoundError, RuntimeError, ShopDetails, ValidationException } from "../../models/models_0";
+import { AppAPIService } from "../AppAPIService";
+import { ServerSerdeContext, Mux as __Mux, Operation as __Operation, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer, ValidationFailure as __ValidationFailure } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type GetShopPublic<Context> = __Operation<GetShopPublicServerInput, GetShopPublicServerOutput, Context>;
+export interface GetShopPublicServerInput extends GetShopInput {
+}
+export declare namespace GetShopPublicServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof GetShopInput.validate>[0]) => __ValidationFailure[];
+}
+export interface GetShopPublicServerOutput extends ShopDetails {
+}
+export type GetShopPublicErrors = ValidationException | RuntimeError | NotFoundError;
+export declare class GetShopPublicSerializer implements __OperationSerializer<AppAPIService<any>, "GetShopPublic", GetShopPublicErrors> {
+    serialize: (input: GetShopPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<GetShopPublicServerInput>;
+    isOperationError(error: any): error is GetShopPublicErrors;
+    serializeError(error: GetShopPublicErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getGetShopPublicHandler: <Context>(operation: __Operation<GetShopPublicServerInput, GetShopPublicServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class GetShopPublicHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a GetShopPublic handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for GetShopPublic
+     * @param mux The {@link __Mux} that verifies which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializer An {@link __OperationSerializer} for GetShopPublic that
+     *                   handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(operation: __Operation<GetShopPublicServerInput, GetShopPublicServerOutput, Context>, mux: __Mux<"AppAPI", "GetShopPublic">, serializer: __OperationSerializer<AppAPIService<Context>, "GetShopPublic", GetShopPublicErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"GetShopPublic">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/GetUser.d.ts

@@ -0,0 +1,41 @@
+import { GetUserInput, GetUserOutput, RuntimeError, ValidationException } from "../../models/models_0";
+import { AppAPIService } from "../AppAPIService";
+import { ServerSerdeContext, Mux as __Mux, Operation as __Operation, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer, ValidationFailure as __ValidationFailure } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type GetUser<Context> = __Operation<GetUserServerInput, GetUserServerOutput, Context>;
+export interface GetUserServerInput extends GetUserInput {
+}
+export declare namespace GetUserServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof GetUserInput.validate>[0]) => __ValidationFailure[];
+}
+export interface GetUserServerOutput extends GetUserOutput {
+}
+export type GetUserErrors = ValidationException | RuntimeError;
+export declare class GetUserSerializer implements __OperationSerializer<AppAPIService<any>, "GetUser", GetUserErrors> {
+    serialize: (input: GetUserServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<GetUserServerInput>;
+    isOperationError(error: any): error is GetUserErrors;
+    serializeError(error: GetUserErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getGetUserHandler: <Context>(operation: __Operation<GetUserServerInput, GetUserServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class GetUserHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a GetUser handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for GetUser
+     * @param mux The {@link __Mux} that verifies which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializer An {@link __OperationSerializer} for GetUser that
+     *                   handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(operation: __Operation<GetUserServerInput, GetUserServerOutput, Context>, mux: __Mux<"AppAPI", "GetUser">, serializer: __OperationSerializer<AppAPIService<Context>, "GetUser", GetUserErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"GetUser">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/LikeOrg.d.ts

@@ -0,0 +1,41 @@
+import { LikeOrgInput, LikeOrgOutput, RuntimeError, ValidationException } from "../../models/models_0";
+import { AppAPIService } from "../AppAPIService";
+import { ServerSerdeContext, Mux as __Mux, Operation as __Operation, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer, ValidationFailure as __ValidationFailure } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type LikeOrg<Context> = __Operation<LikeOrgServerInput, LikeOrgServerOutput, Context>;
+export interface LikeOrgServerInput extends LikeOrgInput {
+}
+export declare namespace LikeOrgServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof LikeOrgInput.validate>[0]) => __ValidationFailure[];
+}
+export interface LikeOrgServerOutput extends LikeOrgOutput {
+}
+export type LikeOrgErrors = ValidationException | RuntimeError;
+export declare class LikeOrgSerializer implements __OperationSerializer<AppAPIService<any>, "LikeOrg", LikeOrgErrors> {
+    serialize: (input: LikeOrgServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<LikeOrgServerInput>;
+    isOperationError(error: any): error is LikeOrgErrors;
+    serializeError(error: LikeOrgErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getLikeOrgHandler: <Context>(operation: __Operation<LikeOrgServerInput, LikeOrgServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class LikeOrgHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a LikeOrg handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for LikeOrg
+     * @param mux The {@link __Mux} that verifies which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializer An {@link __OperationSerializer} for LikeOrg that
+     *                   handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(operation: __Operation<LikeOrgServerInput, LikeOrgServerOutput, Context>, mux: __Mux<"AppAPI", "LikeOrg">, serializer: __OperationSerializer<AppAPIService<Context>, "LikeOrg", LikeOrgErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"LikeOrg">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/NearbyShops.d.ts

@@ -0,0 +1,41 @@
+import { RuntimeError, ShopListInput, ShopListWithPaginationOutput, ValidationException } from "../../models/models_0";
+import { AppAPIService } from "../AppAPIService";
+import { ServerSerdeContext, Mux as __Mux, Operation as __Operation, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer, ValidationFailure as __ValidationFailure } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type NearbyShops<Context> = __Operation<NearbyShopsServerInput, NearbyShopsServerOutput, Context>;
+export interface NearbyShopsServerInput extends ShopListInput {
+}
+export declare namespace NearbyShopsServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof ShopListInput.validate>[0]) => __ValidationFailure[];
+}
+export interface NearbyShopsServerOutput extends ShopListWithPaginationOutput {
+}
+export type NearbyShopsErrors = ValidationException | RuntimeError;
+export declare class NearbyShopsSerializer implements __OperationSerializer<AppAPIService<any>, "NearbyShops", NearbyShopsErrors> {
+    serialize: (input: NearbyShopsServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<NearbyShopsServerInput>;
+    isOperationError(error: any): error is NearbyShopsErrors;
+    serializeError(error: NearbyShopsErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getNearbyShopsHandler: <Context>(operation: __Operation<NearbyShopsServerInput, NearbyShopsServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class NearbyShopsHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a NearbyShops handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for NearbyShops
+     * @param mux The {@link __Mux} that verifies which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializer An {@link __OperationSerializer} for NearbyShops that
+     *                   handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(operation: __Operation<NearbyShopsServerInput, NearbyShopsServerOutput, Context>, mux: __Mux<"AppAPI", "NearbyShops">, serializer: __OperationSerializer<AppAPIService<Context>, "NearbyShops", NearbyShopsErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"NearbyShops">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/NearbyShopsPublic.d.ts

@@ -0,0 +1,41 @@
+import { RuntimeError, ShopListInput, ShopListWithPaginationOutput, ValidationException } from "../../models/models_0";
+import { AppAPIService } from "../AppAPIService";
+import { ServerSerdeContext, Mux as __Mux, Operation as __Operation, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer, ValidationFailure as __ValidationFailure } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type NearbyShopsPublic<Context> = __Operation<NearbyShopsPublicServerInput, NearbyShopsPublicServerOutput, Context>;
+export interface NearbyShopsPublicServerInput extends ShopListInput {
+}
+export declare namespace NearbyShopsPublicServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof ShopListInput.validate>[0]) => __ValidationFailure[];
+}
+export interface NearbyShopsPublicServerOutput extends ShopListWithPaginationOutput {
+}
+export type NearbyShopsPublicErrors = ValidationException | RuntimeError;
+export declare class NearbyShopsPublicSerializer implements __OperationSerializer<AppAPIService<any>, "NearbyShopsPublic", NearbyShopsPublicErrors> {
+    serialize: (input: NearbyShopsPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<NearbyShopsPublicServerInput>;
+    isOperationError(error: any): error is NearbyShopsPublicErrors;
+    serializeError(error: NearbyShopsPublicErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getNearbyShopsPublicHandler: <Context>(operation: __Operation<NearbyShopsPublicServerInput, NearbyShopsPublicServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class NearbyShopsPublicHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a NearbyShopsPublic handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for NearbyShopsPublic
+     * @param mux The {@link __Mux} that verifies which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializer An {@link __OperationSerializer} for NearbyShopsPublic that
+     *                   handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(operation: __Operation<NearbyShopsPublicServerInput, NearbyShopsPublicServerOutput, Context>, mux: __Mux<"AppAPI", "NearbyShopsPublic">, serializer: __OperationSerializer<AppAPIService<Context>, "NearbyShopsPublic", NearbyShopsPublicErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"NearbyShopsPublic">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/NearestShop.d.ts

@@ -0,0 +1,41 @@
+import { EnrichedShop, NearestShopInput, RuntimeError, ValidationException } from "../../models/models_0";
+import { AppAPIService } from "../AppAPIService";
+import { ServerSerdeContext, Mux as __Mux, Operation as __Operation, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer, ValidationFailure as __ValidationFailure } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type NearestShop<Context> = __Operation<NearestShopServerInput, NearestShopServerOutput, Context>;
+export interface NearestShopServerInput extends NearestShopInput {
+}
+export declare namespace NearestShopServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof NearestShopInput.validate>[0]) => __ValidationFailure[];
+}
+export interface NearestShopServerOutput extends EnrichedShop {
+}
+export type NearestShopErrors = ValidationException | RuntimeError;
+export declare class NearestShopSerializer implements __OperationSerializer<AppAPIService<any>, "NearestShop", NearestShopErrors> {
+    serialize: (input: NearestShopServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<NearestShopServerInput>;
+    isOperationError(error: any): error is NearestShopErrors;
+    serializeError(error: NearestShopErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getNearestShopHandler: <Context>(operation: __Operation<NearestShopServerInput, NearestShopServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class NearestShopHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a NearestShop handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for NearestShop
+     * @param mux The {@link __Mux} that verifies which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializer An {@link __OperationSerializer} for NearestShop that
+     *                   handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(operation: __Operation<NearestShopServerInput, NearestShopServerOutput, Context>, mux: __Mux<"AppAPI", "NearestShop">, serializer: __OperationSerializer<AppAPIService<Context>, "NearestShop", NearestShopErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"NearestShop">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}