@sparkrewards/sra-sdk 0.0.1

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

@@ -0,0 +1,41 @@
+import { OnboardUserInput, OnboardUserOutput, 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 OnboardUser<Context> = __Operation<OnboardUserServerInput, OnboardUserServerOutput, Context>;
+export interface OnboardUserServerInput extends OnboardUserInput {
+}
+export declare namespace OnboardUserServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof OnboardUserInput.validate>[0]) => __ValidationFailure[];
+}
+export interface OnboardUserServerOutput extends OnboardUserOutput {
+}
+export type OnboardUserErrors = ValidationException | RuntimeError;
+export declare class OnboardUserSerializer implements __OperationSerializer<AppAPIService<any>, "OnboardUser", OnboardUserErrors> {
+    serialize: (input: OnboardUserServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<OnboardUserServerInput>;
+    isOperationError(error: any): error is OnboardUserErrors;
+    serializeError(error: OnboardUserErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getOnboardUserHandler: <Context>(operation: __Operation<OnboardUserServerInput, OnboardUserServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class OnboardUserHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a OnboardUser handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for OnboardUser
+     * @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 OnboardUser 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<OnboardUserServerInput, OnboardUserServerOutput, Context>, mux: __Mux<"AppAPI", "OnboardUser">, serializer: __OperationSerializer<AppAPIService<Context>, "OnboardUser", OnboardUserErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"OnboardUser">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

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

@@ -0,0 +1,41 @@
+import { EnrichedShop, PinnedShopInput, 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 PinnedShop<Context> = __Operation<PinnedShopServerInput, PinnedShopServerOutput, Context>;
+export interface PinnedShopServerInput extends PinnedShopInput {
+}
+export declare namespace PinnedShopServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof PinnedShopInput.validate>[0]) => __ValidationFailure[];
+}
+export interface PinnedShopServerOutput extends EnrichedShop {
+}
+export type PinnedShopErrors = ValidationException | RuntimeError;
+export declare class PinnedShopSerializer implements __OperationSerializer<AppAPIService<any>, "PinnedShop", PinnedShopErrors> {
+    serialize: (input: PinnedShopServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<PinnedShopServerInput>;
+    isOperationError(error: any): error is PinnedShopErrors;
+    serializeError(error: PinnedShopErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getPinnedShopHandler: <Context>(operation: __Operation<PinnedShopServerInput, PinnedShopServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class PinnedShopHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a PinnedShop handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for PinnedShop
+     * @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 PinnedShop 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<PinnedShopServerInput, PinnedShopServerOutput, Context>, mux: __Mux<"AppAPI", "PinnedShop">, serializer: __OperationSerializer<AppAPIService<Context>, "PinnedShop", PinnedShopErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"PinnedShop">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

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

@@ -0,0 +1,41 @@
+import { EnrichedShop, PinnedShopInput, 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 PinnedShopPublic<Context> = __Operation<PinnedShopPublicServerInput, PinnedShopPublicServerOutput, Context>;
+export interface PinnedShopPublicServerInput extends PinnedShopInput {
+}
+export declare namespace PinnedShopPublicServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof PinnedShopInput.validate>[0]) => __ValidationFailure[];
+}
+export interface PinnedShopPublicServerOutput extends EnrichedShop {
+}
+export type PinnedShopPublicErrors = ValidationException | RuntimeError;
+export declare class PinnedShopPublicSerializer implements __OperationSerializer<AppAPIService<any>, "PinnedShopPublic", PinnedShopPublicErrors> {
+    serialize: (input: PinnedShopPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<PinnedShopPublicServerInput>;
+    isOperationError(error: any): error is PinnedShopPublicErrors;
+    serializeError(error: PinnedShopPublicErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getPinnedShopPublicHandler: <Context>(operation: __Operation<PinnedShopPublicServerInput, PinnedShopPublicServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class PinnedShopPublicHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a PinnedShopPublic handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for PinnedShopPublic
+     * @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 PinnedShopPublic 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<PinnedShopPublicServerInput, PinnedShopPublicServerOutput, Context>, mux: __Mux<"AppAPI", "PinnedShopPublic">, serializer: __OperationSerializer<AppAPIService<Context>, "PinnedShopPublic", PinnedShopPublicErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"PinnedShopPublic">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

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

@@ -0,0 +1,41 @@
+import { PlanGetInput, PlanOutput, 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 Plan<Context> = __Operation<PlanServerInput, PlanServerOutput, Context>;
+export interface PlanServerInput extends PlanGetInput {
+}
+export declare namespace PlanServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof PlanGetInput.validate>[0]) => __ValidationFailure[];
+}
+export interface PlanServerOutput extends PlanOutput {
+}
+export type PlanErrors = ValidationException | RuntimeError;
+export declare class PlanSerializer implements __OperationSerializer<AppAPIService<any>, "Plan", PlanErrors> {
+    serialize: (input: PlanServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<PlanServerInput>;
+    isOperationError(error: any): error is PlanErrors;
+    serializeError(error: PlanErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getPlanHandler: <Context>(operation: __Operation<PlanServerInput, PlanServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class PlanHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a Plan handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for Plan
+     * @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 Plan 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<PlanServerInput, PlanServerOutput, Context>, mux: __Mux<"AppAPI", "Plan">, serializer: __OperationSerializer<AppAPIService<Context>, "Plan", PlanErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"Plan">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

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

@@ -0,0 +1,41 @@
+import { PlanGetInput, PlanOutput, 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 PlanPublic<Context> = __Operation<PlanPublicServerInput, PlanPublicServerOutput, Context>;
+export interface PlanPublicServerInput extends PlanGetInput {
+}
+export declare namespace PlanPublicServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof PlanGetInput.validate>[0]) => __ValidationFailure[];
+}
+export interface PlanPublicServerOutput extends PlanOutput {
+}
+export type PlanPublicErrors = ValidationException | RuntimeError;
+export declare class PlanPublicSerializer implements __OperationSerializer<AppAPIService<any>, "PlanPublic", PlanPublicErrors> {
+    serialize: (input: PlanPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<PlanPublicServerInput>;
+    isOperationError(error: any): error is PlanPublicErrors;
+    serializeError(error: PlanPublicErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getPlanPublicHandler: <Context>(operation: __Operation<PlanPublicServerInput, PlanPublicServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class PlanPublicHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a PlanPublic handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for PlanPublic
+     * @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 PlanPublic 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<PlanPublicServerInput, PlanPublicServerOutput, Context>, mux: __Mux<"AppAPI", "PlanPublic">, serializer: __OperationSerializer<AppAPIService<Context>, "PlanPublic", PlanPublicErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"PlanPublic">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/Plans.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 Plans<Context> = __Operation<PlansServerInput, PlansServerOutput, Context>;
+export interface PlansServerInput extends PlansListInput {
+}
+export declare namespace PlansServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof PlansListInput.validate>[0]) => __ValidationFailure[];
+}
+export interface PlansServerOutput extends PlansOutput {
+}
+export type PlansErrors = ValidationException | RuntimeError;
+export declare class PlansSerializer implements __OperationSerializer<AppAPIService<any>, "Plans", PlansErrors> {
+    serialize: (input: PlansServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<PlansServerInput>;
+    isOperationError(error: any): error is PlansErrors;
+    serializeError(error: PlansErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getPlansHandler: <Context>(operation: __Operation<PlansServerInput, PlansServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class PlansHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a Plans handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for Plans
+     * @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 Plans 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<PlansServerInput, PlansServerOutput, Context>, mux: __Mux<"AppAPI", "Plans">, serializer: __OperationSerializer<AppAPIService<Context>, "Plans", PlansErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"Plans">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/PopularShops.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 PopularShops<Context> = __Operation<PopularShopsServerInput, PopularShopsServerOutput, Context>;
+export interface PopularShopsServerInput extends ShopListInput {
+}
+export declare namespace PopularShopsServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof ShopListInput.validate>[0]) => __ValidationFailure[];
+}
+export interface PopularShopsServerOutput extends ShopListWithPaginationOutput {
+}
+export type PopularShopsErrors = ValidationException | RuntimeError;
+export declare class PopularShopsSerializer implements __OperationSerializer<AppAPIService<any>, "PopularShops", PopularShopsErrors> {
+    serialize: (input: PopularShopsServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<PopularShopsServerInput>;
+    isOperationError(error: any): error is PopularShopsErrors;
+    serializeError(error: PopularShopsErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getPopularShopsHandler: <Context>(operation: __Operation<PopularShopsServerInput, PopularShopsServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class PopularShopsHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a PopularShops handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for PopularShops
+     * @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 PopularShops 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<PopularShopsServerInput, PopularShopsServerOutput, Context>, mux: __Mux<"AppAPI", "PopularShops">, serializer: __OperationSerializer<AppAPIService<Context>, "PopularShops", PopularShopsErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"PopularShops">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/server/operations/PopularShopsPublic.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 PopularShopsPublic<Context> = __Operation<PopularShopsPublicServerInput, PopularShopsPublicServerOutput, Context>;
+export interface PopularShopsPublicServerInput extends ShopListInput {
+}
+export declare namespace PopularShopsPublicServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof ShopListInput.validate>[0]) => __ValidationFailure[];
+}
+export interface PopularShopsPublicServerOutput extends ShopListWithPaginationOutput {
+}
+export type PopularShopsPublicErrors = ValidationException | RuntimeError;
+export declare class PopularShopsPublicSerializer implements __OperationSerializer<AppAPIService<any>, "PopularShopsPublic", PopularShopsPublicErrors> {
+    serialize: (input: PopularShopsPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<PopularShopsPublicServerInput>;
+    isOperationError(error: any): error is PopularShopsPublicErrors;
+    serializeError(error: PopularShopsPublicErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getPopularShopsPublicHandler: <Context>(operation: __Operation<PopularShopsPublicServerInput, PopularShopsPublicServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class PopularShopsPublicHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a PopularShopsPublic handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for PopularShopsPublic
+     * @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 PopularShopsPublic 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<PopularShopsPublicServerInput, PopularShopsPublicServerOutput, Context>, mux: __Mux<"AppAPI", "PopularShopsPublic">, serializer: __OperationSerializer<AppAPIService<Context>, "PopularShopsPublic", PopularShopsPublicErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"PopularShopsPublic">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

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

@@ -0,0 +1,41 @@
+import { RadiusShopsOutput, RuntimeError, ShopListInput, 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 RadiusShops<Context> = __Operation<RadiusShopsServerInput, RadiusShopsServerOutput, Context>;
+export interface RadiusShopsServerInput extends ShopListInput {
+}
+export declare namespace RadiusShopsServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof ShopListInput.validate>[0]) => __ValidationFailure[];
+}
+export interface RadiusShopsServerOutput extends RadiusShopsOutput {
+}
+export type RadiusShopsErrors = ValidationException | RuntimeError;
+export declare class RadiusShopsSerializer implements __OperationSerializer<AppAPIService<any>, "RadiusShops", RadiusShopsErrors> {
+    serialize: (input: RadiusShopsServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<RadiusShopsServerInput>;
+    isOperationError(error: any): error is RadiusShopsErrors;
+    serializeError(error: RadiusShopsErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getRadiusShopsHandler: <Context>(operation: __Operation<RadiusShopsServerInput, RadiusShopsServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class RadiusShopsHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a RadiusShops handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for RadiusShops
+     * @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 RadiusShops 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<RadiusShopsServerInput, RadiusShopsServerOutput, Context>, mux: __Mux<"AppAPI", "RadiusShops">, serializer: __OperationSerializer<AppAPIService<Context>, "RadiusShops", RadiusShopsErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"RadiusShops">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

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

@@ -0,0 +1,41 @@
+import { InvalidOperationError, RecordVisitInput, RecordVisitOutput, 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 RecordVisit<Context> = __Operation<RecordVisitServerInput, RecordVisitServerOutput, Context>;
+export interface RecordVisitServerInput extends RecordVisitInput {
+}
+export declare namespace RecordVisitServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof RecordVisitInput.validate>[0]) => __ValidationFailure[];
+}
+export interface RecordVisitServerOutput extends RecordVisitOutput {
+}
+export type RecordVisitErrors = ValidationException | RuntimeError | InvalidOperationError;
+export declare class RecordVisitSerializer implements __OperationSerializer<AppAPIService<any>, "RecordVisit", RecordVisitErrors> {
+    serialize: (input: RecordVisitServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<RecordVisitServerInput>;
+    isOperationError(error: any): error is RecordVisitErrors;
+    serializeError(error: RecordVisitErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getRecordVisitHandler: <Context>(operation: __Operation<RecordVisitServerInput, RecordVisitServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class RecordVisitHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a RecordVisit handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for RecordVisit
+     * @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 RecordVisit 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<RecordVisitServerInput, RecordVisitServerOutput, Context>, mux: __Mux<"AppAPI", "RecordVisit">, serializer: __OperationSerializer<AppAPIService<Context>, "RecordVisit", RecordVisitErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"RecordVisit">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

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

@@ -0,0 +1,41 @@
+import { RedeemFirstTimeRewardInput, RedeemRewardOutput, 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 RedeemFirstTimeReward<Context> = __Operation<RedeemFirstTimeRewardServerInput, RedeemFirstTimeRewardServerOutput, Context>;
+export interface RedeemFirstTimeRewardServerInput extends RedeemFirstTimeRewardInput {
+}
+export declare namespace RedeemFirstTimeRewardServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof RedeemFirstTimeRewardInput.validate>[0]) => __ValidationFailure[];
+}
+export interface RedeemFirstTimeRewardServerOutput extends RedeemRewardOutput {
+}
+export type RedeemFirstTimeRewardErrors = ValidationException | RuntimeError;
+export declare class RedeemFirstTimeRewardSerializer implements __OperationSerializer<AppAPIService<any>, "RedeemFirstTimeReward", RedeemFirstTimeRewardErrors> {
+    serialize: (input: RedeemFirstTimeRewardServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<RedeemFirstTimeRewardServerInput>;
+    isOperationError(error: any): error is RedeemFirstTimeRewardErrors;
+    serializeError(error: RedeemFirstTimeRewardErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getRedeemFirstTimeRewardHandler: <Context>(operation: __Operation<RedeemFirstTimeRewardServerInput, RedeemFirstTimeRewardServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class RedeemFirstTimeRewardHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a RedeemFirstTimeReward handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for RedeemFirstTimeReward
+     * @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 RedeemFirstTimeReward 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<RedeemFirstTimeRewardServerInput, RedeemFirstTimeRewardServerOutput, Context>, mux: __Mux<"AppAPI", "RedeemFirstTimeReward">, serializer: __OperationSerializer<AppAPIService<Context>, "RedeemFirstTimeReward", RedeemFirstTimeRewardErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"RedeemFirstTimeReward">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

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

@@ -0,0 +1,41 @@
+import { RedeemPointRewardInput, RedeemPointRewardOutput, 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 RedeemPointReward<Context> = __Operation<RedeemPointRewardServerInput, RedeemPointRewardServerOutput, Context>;
+export interface RedeemPointRewardServerInput extends RedeemPointRewardInput {
+}
+export declare namespace RedeemPointRewardServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof RedeemPointRewardInput.validate>[0]) => __ValidationFailure[];
+}
+export interface RedeemPointRewardServerOutput extends RedeemPointRewardOutput {
+}
+export type RedeemPointRewardErrors = ValidationException | RuntimeError;
+export declare class RedeemPointRewardSerializer implements __OperationSerializer<AppAPIService<any>, "RedeemPointReward", RedeemPointRewardErrors> {
+    serialize: (input: RedeemPointRewardServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<RedeemPointRewardServerInput>;
+    isOperationError(error: any): error is RedeemPointRewardErrors;
+    serializeError(error: RedeemPointRewardErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getRedeemPointRewardHandler: <Context>(operation: __Operation<RedeemPointRewardServerInput, RedeemPointRewardServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class RedeemPointRewardHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a RedeemPointReward handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for RedeemPointReward
+     * @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 RedeemPointReward 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<RedeemPointRewardServerInput, RedeemPointRewardServerOutput, Context>, mux: __Mux<"AppAPI", "RedeemPointReward">, serializer: __OperationSerializer<AppAPIService<Context>, "RedeemPointReward", RedeemPointRewardErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"RedeemPointReward">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

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

@@ -0,0 +1,41 @@
+import { RedeemRewardOutput, RedeemVisitRewardInput, 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 RedeemVisitReward<Context> = __Operation<RedeemVisitRewardServerInput, RedeemVisitRewardServerOutput, Context>;
+export interface RedeemVisitRewardServerInput extends RedeemVisitRewardInput {
+}
+export declare namespace RedeemVisitRewardServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof RedeemVisitRewardInput.validate>[0]) => __ValidationFailure[];
+}
+export interface RedeemVisitRewardServerOutput extends RedeemRewardOutput {
+}
+export type RedeemVisitRewardErrors = ValidationException | RuntimeError;
+export declare class RedeemVisitRewardSerializer implements __OperationSerializer<AppAPIService<any>, "RedeemVisitReward", RedeemVisitRewardErrors> {
+    serialize: (input: RedeemVisitRewardServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<RedeemVisitRewardServerInput>;
+    isOperationError(error: any): error is RedeemVisitRewardErrors;
+    serializeError(error: RedeemVisitRewardErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getRedeemVisitRewardHandler: <Context>(operation: __Operation<RedeemVisitRewardServerInput, RedeemVisitRewardServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class RedeemVisitRewardHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a RedeemVisitReward handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for RedeemVisitReward
+     * @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 RedeemVisitReward 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<RedeemVisitRewardServerInput, RedeemVisitRewardServerOutput, Context>, mux: __Mux<"AppAPI", "RedeemVisitReward">, serializer: __OperationSerializer<AppAPIService<Context>, "RedeemVisitReward", RedeemVisitRewardErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"RedeemVisitReward">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

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

@@ -0,0 +1,41 @@
+import { RuntimeError, SearchShopsInput, 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 SearchShopsPublic<Context> = __Operation<SearchShopsPublicServerInput, SearchShopsPublicServerOutput, Context>;
+export interface SearchShopsPublicServerInput extends SearchShopsInput {
+}
+export declare namespace SearchShopsPublicServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof SearchShopsInput.validate>[0]) => __ValidationFailure[];
+}
+export interface SearchShopsPublicServerOutput extends ShopListWithPaginationOutput {
+}
+export type SearchShopsPublicErrors = ValidationException | RuntimeError;
+export declare class SearchShopsPublicSerializer implements __OperationSerializer<AppAPIService<any>, "SearchShopsPublic", SearchShopsPublicErrors> {
+    serialize: (input: SearchShopsPublicServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<SearchShopsPublicServerInput>;
+    isOperationError(error: any): error is SearchShopsPublicErrors;
+    serializeError(error: SearchShopsPublicErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getSearchShopsPublicHandler: <Context>(operation: __Operation<SearchShopsPublicServerInput, SearchShopsPublicServerOutput, Context>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class SearchShopsPublicHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a SearchShopsPublic handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for SearchShopsPublic
+     * @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 SearchShopsPublic 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<SearchShopsPublicServerInput, SearchShopsPublicServerOutput, Context>, mux: __Mux<"AppAPI", "SearchShopsPublic">, serializer: __OperationSerializer<AppAPIService<Context>, "SearchShopsPublic", SearchShopsPublicErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"SearchShopsPublic">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}