@anweather/game-plugin-ssdk 1.2.0

package/dist-types/src/server/operations/DescribeSaveFile.d.ts

@@ -0,0 +1,41 @@
+import { DescribeSaveFileInput, DescribeSaveFileOutput } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 DescribeSaveFile<Context> = __Operation<DescribeSaveFileServerInput, DescribeSaveFileServerOutput, Context>;
+export interface DescribeSaveFileServerInput extends DescribeSaveFileInput {
+}
+export declare namespace DescribeSaveFileServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof DescribeSaveFileInput.validate>[0]) => __ValidationFailure[];
+}
+export interface DescribeSaveFileServerOutput extends DescribeSaveFileOutput {
+}
+export type DescribeSaveFileErrors = never;
+export declare class DescribeSaveFileSerializer implements __OperationSerializer<GamePluginService<any>, "DescribeSaveFile", DescribeSaveFileErrors> {
+    serialize: (input: DescribeSaveFileServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<DescribeSaveFileServerInput>;
+    isOperationError(error: any): error is DescribeSaveFileErrors;
+    serializeError(error: DescribeSaveFileErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getDescribeSaveFileHandler: <Context>(operation: __Operation<DescribeSaveFileServerInput, DescribeSaveFileServerOutput, Context>, customizer: __ValidationCustomizer<"DescribeSaveFile">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class DescribeSaveFileHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a DescribeSaveFile handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for DescribeSaveFile
+     * @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 DescribeSaveFile 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<DescribeSaveFileServerInput, DescribeSaveFileServerOutput, Context>, mux: __Mux<"GamePlugin", "DescribeSaveFile">, serializer: __OperationSerializer<GamePluginService<Context>, "DescribeSaveFile", DescribeSaveFileErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"DescribeSaveFile">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/src/server/operations/GetGameResult.d.ts

@@ -0,0 +1,41 @@
+import { GameResultOutput, PluginStateOnlyInput } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 GetGameResult<Context> = __Operation<GetGameResultServerInput, GetGameResultServerOutput, Context>;
+export interface GetGameResultServerInput extends PluginStateOnlyInput {
+}
+export declare namespace GetGameResultServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof PluginStateOnlyInput.validate>[0]) => __ValidationFailure[];
+}
+export interface GetGameResultServerOutput extends GameResultOutput {
+}
+export type GetGameResultErrors = never;
+export declare class GetGameResultSerializer implements __OperationSerializer<GamePluginService<any>, "GetGameResult", GetGameResultErrors> {
+    serialize: (input: GetGameResultServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<GetGameResultServerInput>;
+    isOperationError(error: any): error is GetGameResultErrors;
+    serializeError(error: GetGameResultErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getGetGameResultHandler: <Context>(operation: __Operation<GetGameResultServerInput, GetGameResultServerOutput, Context>, customizer: __ValidationCustomizer<"GetGameResult">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class GetGameResultHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a GetGameResult handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for GetGameResult
+     * @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 GetGameResult 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<GetGameResultServerInput, GetGameResultServerOutput, Context>, mux: __Mux<"GamePlugin", "GetGameResult">, serializer: __OperationSerializer<GamePluginService<Context>, "GetGameResult", GetGameResultErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"GetGameResult">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/src/server/operations/GetGameStatus.d.ts

@@ -0,0 +1,41 @@
+import { GameStatusOutput, PluginStateOnlyInput } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 GetGameStatus<Context> = __Operation<GetGameStatusServerInput, GetGameStatusServerOutput, Context>;
+export interface GetGameStatusServerInput extends PluginStateOnlyInput {
+}
+export declare namespace GetGameStatusServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof PluginStateOnlyInput.validate>[0]) => __ValidationFailure[];
+}
+export interface GetGameStatusServerOutput extends GameStatusOutput {
+}
+export type GetGameStatusErrors = never;
+export declare class GetGameStatusSerializer implements __OperationSerializer<GamePluginService<any>, "GetGameStatus", GetGameStatusErrors> {
+    serialize: (input: GetGameStatusServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<GetGameStatusServerInput>;
+    isOperationError(error: any): error is GetGameStatusErrors;
+    serializeError(error: GetGameStatusErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getGetGameStatusHandler: <Context>(operation: __Operation<GetGameStatusServerInput, GetGameStatusServerOutput, Context>, customizer: __ValidationCustomizer<"GetGameStatus">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class GetGameStatusHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a GetGameStatus handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for GetGameStatus
+     * @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 GetGameStatus 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<GetGameStatusServerInput, GetGameStatusServerOutput, Context>, mux: __Mux<"GamePlugin", "GetGameStatus">, serializer: __OperationSerializer<GamePluginService<Context>, "GetGameStatus", GetGameStatusErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"GetGameStatus">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/src/server/operations/GetMetadata.d.ts

@@ -0,0 +1,41 @@
+import { GameTypeMetadata } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 GetMetadata<Context> = __Operation<GetMetadataServerInput, GetMetadataServerOutput, Context>;
+export interface GetMetadataServerInput {
+}
+export declare namespace GetMetadataServerInput {
+    /**
+     * @internal
+     */
+    const validate: () => __ValidationFailure[];
+}
+export interface GetMetadataServerOutput extends GameTypeMetadata {
+}
+export type GetMetadataErrors = never;
+export declare class GetMetadataSerializer implements __OperationSerializer<GamePluginService<any>, "GetMetadata", GetMetadataErrors> {
+    serialize: (input: GetMetadataServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<GetMetadataServerInput>;
+    isOperationError(error: any): error is GetMetadataErrors;
+    serializeError(error: GetMetadataErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getGetMetadataHandler: <Context>(operation: __Operation<GetMetadataServerInput, GetMetadataServerOutput, Context>, customizer: __ValidationCustomizer<"GetMetadata">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class GetMetadataHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a GetMetadata handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for GetMetadata
+     * @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 GetMetadata 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<GetMetadataServerInput, GetMetadataServerOutput, Context>, mux: __Mux<"GamePlugin", "GetMetadata">, serializer: __OperationSerializer<GamePluginService<Context>, "GetMetadata", GetMetadataErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"GetMetadata">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/src/server/operations/GetPlayerView.d.ts

@@ -0,0 +1,41 @@
+import { GetPlayerViewInput, GetPlayerViewOutput } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 GetPlayerView<Context> = __Operation<GetPlayerViewServerInput, GetPlayerViewServerOutput, Context>;
+export interface GetPlayerViewServerInput extends GetPlayerViewInput {
+}
+export declare namespace GetPlayerViewServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof GetPlayerViewInput.validate>[0]) => __ValidationFailure[];
+}
+export interface GetPlayerViewServerOutput extends GetPlayerViewOutput {
+}
+export type GetPlayerViewErrors = never;
+export declare class GetPlayerViewSerializer implements __OperationSerializer<GamePluginService<any>, "GetPlayerView", GetPlayerViewErrors> {
+    serialize: (input: GetPlayerViewServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<GetPlayerViewServerInput>;
+    isOperationError(error: any): error is GetPlayerViewErrors;
+    serializeError(error: GetPlayerViewErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getGetPlayerViewHandler: <Context>(operation: __Operation<GetPlayerViewServerInput, GetPlayerViewServerOutput, Context>, customizer: __ValidationCustomizer<"GetPlayerView">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class GetPlayerViewHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a GetPlayerView handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for GetPlayerView
+     * @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 GetPlayerView 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<GetPlayerViewServerInput, GetPlayerViewServerOutput, Context>, mux: __Mux<"GamePlugin", "GetPlayerView">, serializer: __OperationSerializer<GamePluginService<Context>, "GetPlayerView", GetPlayerViewErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"GetPlayerView">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/src/server/operations/GetSaveFileEditorState.d.ts

@@ -0,0 +1,41 @@
+import { GetSaveFileEditorStateInput, GetSaveFileEditorStateOutput } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 GetSaveFileEditorState<Context> = __Operation<GetSaveFileEditorStateServerInput, GetSaveFileEditorStateServerOutput, Context>;
+export interface GetSaveFileEditorStateServerInput extends GetSaveFileEditorStateInput {
+}
+export declare namespace GetSaveFileEditorStateServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof GetSaveFileEditorStateInput.validate>[0]) => __ValidationFailure[];
+}
+export interface GetSaveFileEditorStateServerOutput extends GetSaveFileEditorStateOutput {
+}
+export type GetSaveFileEditorStateErrors = never;
+export declare class GetSaveFileEditorStateSerializer implements __OperationSerializer<GamePluginService<any>, "GetSaveFileEditorState", GetSaveFileEditorStateErrors> {
+    serialize: (input: GetSaveFileEditorStateServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<GetSaveFileEditorStateServerInput>;
+    isOperationError(error: any): error is GetSaveFileEditorStateErrors;
+    serializeError(error: GetSaveFileEditorStateErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getGetSaveFileEditorStateHandler: <Context>(operation: __Operation<GetSaveFileEditorStateServerInput, GetSaveFileEditorStateServerOutput, Context>, customizer: __ValidationCustomizer<"GetSaveFileEditorState">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class GetSaveFileEditorStateHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a GetSaveFileEditorState handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for GetSaveFileEditorState
+     * @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 GetSaveFileEditorState 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<GetSaveFileEditorStateServerInput, GetSaveFileEditorStateServerOutput, Context>, mux: __Mux<"GamePlugin", "GetSaveFileEditorState">, serializer: __OperationSerializer<GamePluginService<Context>, "GetSaveFileEditorState", GetSaveFileEditorStateErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"GetSaveFileEditorState">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/src/server/operations/Health.d.ts

@@ -0,0 +1,41 @@
+import { HealthOutput } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 Health<Context> = __Operation<HealthServerInput, HealthServerOutput, Context>;
+export interface HealthServerInput {
+}
+export declare namespace HealthServerInput {
+    /**
+     * @internal
+     */
+    const validate: () => __ValidationFailure[];
+}
+export interface HealthServerOutput extends HealthOutput {
+}
+export type HealthErrors = never;
+export declare class HealthSerializer implements __OperationSerializer<GamePluginService<any>, "Health", HealthErrors> {
+    serialize: (input: HealthServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<HealthServerInput>;
+    isOperationError(error: any): error is HealthErrors;
+    serializeError(error: HealthErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getHealthHandler: <Context>(operation: __Operation<HealthServerInput, HealthServerOutput, Context>, customizer: __ValidationCustomizer<"Health">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class HealthHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a Health handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for Health
+     * @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 Health 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<HealthServerInput, HealthServerOutput, Context>, mux: __Mux<"GamePlugin", "Health">, serializer: __OperationSerializer<GamePluginService<Context>, "Health", HealthErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"Health">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/src/server/operations/InitializeGame.d.ts

@@ -0,0 +1,41 @@
+import { InitializeGameInput, PluginStateUpdate } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 InitializeGame<Context> = __Operation<InitializeGameServerInput, InitializeGameServerOutput, Context>;
+export interface InitializeGameServerInput extends InitializeGameInput {
+}
+export declare namespace InitializeGameServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof InitializeGameInput.validate>[0]) => __ValidationFailure[];
+}
+export interface InitializeGameServerOutput extends PluginStateUpdate {
+}
+export type InitializeGameErrors = never;
+export declare class InitializeGameSerializer implements __OperationSerializer<GamePluginService<any>, "InitializeGame", InitializeGameErrors> {
+    serialize: (input: InitializeGameServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<InitializeGameServerInput>;
+    isOperationError(error: any): error is InitializeGameErrors;
+    serializeError(error: InitializeGameErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getInitializeGameHandler: <Context>(operation: __Operation<InitializeGameServerInput, InitializeGameServerOutput, Context>, customizer: __ValidationCustomizer<"InitializeGame">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class InitializeGameHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a InitializeGame handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for InitializeGame
+     * @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 InitializeGame 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<InitializeGameServerInput, InitializeGameServerOutput, Context>, mux: __Mux<"GamePlugin", "InitializeGame">, serializer: __OperationSerializer<GamePluginService<Context>, "InitializeGame", InitializeGameErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"InitializeGame">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/src/server/operations/IsConfigMove.d.ts

@@ -0,0 +1,41 @@
+import { IsConfigMoveInput, IsConfigMoveOutput } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 IsConfigMove<Context> = __Operation<IsConfigMoveServerInput, IsConfigMoveServerOutput, Context>;
+export interface IsConfigMoveServerInput extends IsConfigMoveInput {
+}
+export declare namespace IsConfigMoveServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof IsConfigMoveInput.validate>[0]) => __ValidationFailure[];
+}
+export interface IsConfigMoveServerOutput extends IsConfigMoveOutput {
+}
+export type IsConfigMoveErrors = never;
+export declare class IsConfigMoveSerializer implements __OperationSerializer<GamePluginService<any>, "IsConfigMove", IsConfigMoveErrors> {
+    serialize: (input: IsConfigMoveServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<IsConfigMoveServerInput>;
+    isOperationError(error: any): error is IsConfigMoveErrors;
+    serializeError(error: IsConfigMoveErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getIsConfigMoveHandler: <Context>(operation: __Operation<IsConfigMoveServerInput, IsConfigMoveServerOutput, Context>, customizer: __ValidationCustomizer<"IsConfigMove">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class IsConfigMoveHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a IsConfigMove handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for IsConfigMove
+     * @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 IsConfigMove 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<IsConfigMoveServerInput, IsConfigMoveServerOutput, Context>, mux: __Mux<"GamePlugin", "IsConfigMove">, serializer: __OperationSerializer<GamePluginService<Context>, "IsConfigMove", IsConfigMoveErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"IsConfigMove">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/src/server/operations/IsOutOfTurnMove.d.ts

@@ -0,0 +1,41 @@
+import { IsOutOfTurnMoveInput, IsOutOfTurnMoveOutput } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 IsOutOfTurnMove<Context> = __Operation<IsOutOfTurnMoveServerInput, IsOutOfTurnMoveServerOutput, Context>;
+export interface IsOutOfTurnMoveServerInput extends IsOutOfTurnMoveInput {
+}
+export declare namespace IsOutOfTurnMoveServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof IsOutOfTurnMoveInput.validate>[0]) => __ValidationFailure[];
+}
+export interface IsOutOfTurnMoveServerOutput extends IsOutOfTurnMoveOutput {
+}
+export type IsOutOfTurnMoveErrors = never;
+export declare class IsOutOfTurnMoveSerializer implements __OperationSerializer<GamePluginService<any>, "IsOutOfTurnMove", IsOutOfTurnMoveErrors> {
+    serialize: (input: IsOutOfTurnMoveServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<IsOutOfTurnMoveServerInput>;
+    isOperationError(error: any): error is IsOutOfTurnMoveErrors;
+    serializeError(error: IsOutOfTurnMoveErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getIsOutOfTurnMoveHandler: <Context>(operation: __Operation<IsOutOfTurnMoveServerInput, IsOutOfTurnMoveServerOutput, Context>, customizer: __ValidationCustomizer<"IsOutOfTurnMove">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class IsOutOfTurnMoveHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a IsOutOfTurnMove handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for IsOutOfTurnMove
+     * @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 IsOutOfTurnMove 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<IsOutOfTurnMoveServerInput, IsOutOfTurnMoveServerOutput, Context>, mux: __Mux<"GamePlugin", "IsOutOfTurnMove">, serializer: __OperationSerializer<GamePluginService<Context>, "IsOutOfTurnMove", IsOutOfTurnMoveErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"IsOutOfTurnMove">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/src/server/operations/SelectBotMove.d.ts

@@ -0,0 +1,41 @@
+import { SelectBotMoveInput, SelectBotMoveOutput } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 SelectBotMove<Context> = __Operation<SelectBotMoveServerInput, SelectBotMoveServerOutput, Context>;
+export interface SelectBotMoveServerInput extends SelectBotMoveInput {
+}
+export declare namespace SelectBotMoveServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof SelectBotMoveInput.validate>[0]) => __ValidationFailure[];
+}
+export interface SelectBotMoveServerOutput extends SelectBotMoveOutput {
+}
+export type SelectBotMoveErrors = never;
+export declare class SelectBotMoveSerializer implements __OperationSerializer<GamePluginService<any>, "SelectBotMove", SelectBotMoveErrors> {
+    serialize: (input: SelectBotMoveServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<SelectBotMoveServerInput>;
+    isOperationError(error: any): error is SelectBotMoveErrors;
+    serializeError(error: SelectBotMoveErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getSelectBotMoveHandler: <Context>(operation: __Operation<SelectBotMoveServerInput, SelectBotMoveServerOutput, Context>, customizer: __ValidationCustomizer<"SelectBotMove">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class SelectBotMoveHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a SelectBotMove handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for SelectBotMove
+     * @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 SelectBotMove 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<SelectBotMoveServerInput, SelectBotMoveServerOutput, Context>, mux: __Mux<"GamePlugin", "SelectBotMove">, serializer: __OperationSerializer<GamePluginService<Context>, "SelectBotMove", SelectBotMoveErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"SelectBotMove">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

package/dist-types/src/server/operations/ValidateMove.d.ts

@@ -0,0 +1,41 @@
+import { MoveValidation, ValidateMoveInput } from "../../models/models_0";
+import { GamePluginService } from "../GamePluginService";
+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 ValidateMove<Context> = __Operation<ValidateMoveServerInput, ValidateMoveServerOutput, Context>;
+export interface ValidateMoveServerInput extends ValidateMoveInput {
+}
+export declare namespace ValidateMoveServerInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: Parameters<typeof ValidateMoveInput.validate>[0]) => __ValidationFailure[];
+}
+export interface ValidateMoveServerOutput extends MoveValidation {
+}
+export type ValidateMoveErrors = never;
+export declare class ValidateMoveSerializer implements __OperationSerializer<GamePluginService<any>, "ValidateMove", ValidateMoveErrors> {
+    serialize: (input: ValidateMoveServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+    deserialize: (output: __HttpRequest, context: import("@smithy/types").SerdeContext) => Promise<ValidateMoveServerInput>;
+    isOperationError(error: any): error is ValidateMoveErrors;
+    serializeError(error: ValidateMoveErrors, ctx: ServerSerdeContext): Promise<__HttpResponse>;
+}
+export declare const getValidateMoveHandler: <Context>(operation: __Operation<ValidateMoveServerInput, ValidateMoveServerOutput, Context>, customizer: __ValidationCustomizer<"ValidateMove">) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;
+export declare class ValidateMoveHandler<Context> implements __ServiceHandler<Context> {
+    private readonly operation;
+    private readonly mux;
+    private readonly serializer;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a ValidateMove handler.
+     * @param operation The {@link __Operation} implementation that supplies the business logic for ValidateMove
+     * @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 ValidateMove 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<ValidateMoveServerInput, ValidateMoveServerOutput, Context>, mux: __Mux<"GamePlugin", "ValidateMove">, serializer: __OperationSerializer<GamePluginService<Context>, "ValidateMove", ValidateMoveErrors>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<"ValidateMove">);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}

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

@@ -0,0 +1,15 @@
+export * from "./ApplyMove";
+export * from "./ApplySaveFileEdit";
+export * from "./AssignParticipants";
+export * from "./DescribeSaveFile";
+export * from "./GetGameResult";
+export * from "./GetGameStatus";
+export * from "./GetMetadata";
+export * from "./GetPlayerView";
+export * from "./GetSaveFileEditorState";
+export * from "./Health";
+export * from "./InitializeGame";
+export * from "./IsConfigMove";
+export * from "./IsOutOfTurnMove";
+export * from "./SelectBotMove";
+export * from "./ValidateMove";

package/package.json

@@ -0,0 +1,88 @@
+{
+    "name": "@anweather/game-plugin-ssdk",
+    "description": "Generated GamePlugin RPC types/server (plugin-protocol/model/game-plugin.smithy) plus a hand-written Express bridge and default-handler wrapper (./runtime) -- see plugin-protocol/CLAUDE.md's \"Publishing for cross-repo plugins\".",
+    "version": "1.2.0",
+    "scripts": {
+        "build": "concurrently 'npm:build:cjs' 'npm:build:es' 'npm:build:types'",
+        "build:cjs": "tsc -p tsconfig.cjs.json",
+        "build:es": "tsc -p tsconfig.es.json",
+        "build:types": "tsc -p tsconfig.types.json",
+        "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
+        "clean": "rimraf ./dist-* && rimraf *.tsbuildinfo || exit 0",
+        "prepack": "npm run clean && npm run build"
+    },
+    "main": "./dist-cjs/src/index.js",
+    "types": "./dist-types/src/index.d.ts",
+    "module": "./dist-es/src/index.js",
+    "exports": {
+        ".": {
+            "types": "./dist-types/src/index.d.ts",
+            "require": "./dist-cjs/src/index.js",
+            "default": "./dist-cjs/src/index.js"
+        },
+        "./runtime": {
+            "types": "./dist-types/runtime/index.d.ts",
+            "require": "./dist-cjs/runtime/index.js",
+            "default": "./dist-cjs/runtime/index.js"
+        }
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "sideEffects": false,
+    "peerDependencies": {
+        "express": "^4.21.2"
+    },
+    "dependencies": {
+        "tslib": "^2.6.2",
+        "@aws-crypto/sha256-browser": "5.2.0",
+        "@aws-crypto/sha256-js": "5.2.0",
+        "@aws-sdk/core": "3.835.0",
+        "@aws-sdk/types": "3.821.0",
+        "@aws-smithy/server-common": "1.0.0-alpha.10",
+        "@smithy/config-resolver": "^4.1.4",
+        "@smithy/fetch-http-handler": "^5.0.4",
+        "@smithy/hash-node": "^4.0.4",
+        "@smithy/invalid-dependency": "^4.0.4",
+        "@smithy/middleware-content-length": "^4.0.4",
+        "@smithy/middleware-retry": "^4.1.13",
+        "@smithy/middleware-serde": "^4.0.8",
+        "@smithy/middleware-stack": "^4.0.4",
+        "@smithy/node-http-handler": "^4.0.6",
+        "@smithy/protocol-http": "^5.1.2",
+        "@smithy/smithy-client": "^4.4.4",
+        "@smithy/types": "^4.3.1",
+        "@smithy/url-parser": "^4.0.4",
+        "@smithy/util-base64": "^4.0.0",
+        "@smithy/util-body-length-browser": "^4.0.0",
+        "@smithy/util-body-length-node": "^4.0.0",
+        "@smithy/util-defaults-mode-browser": "^4.0.20",
+        "@smithy/util-defaults-mode-node": "^4.0.20",
+        "@smithy/util-endpoints": "^3.0.6",
+        "@smithy/util-utf8": "^4.0.0"
+    },
+    "devDependencies": {
+        "@tsconfig/node18": "18.2.4",
+        "@types/express": "^4.17.21",
+        "concurrently": "7.0.0",
+        "downlevel-dts": "0.10.1",
+        "express": "^4.21.2",
+        "rimraf": "^3.0.0",
+        "typescript": "~5.8.3",
+        "@types/node": "^18.19.69"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "typesVersions": {
+        "<4.0": {
+            "dist-types/*": [
+                "dist-types/ts3.4/*"
+            ]
+        }
+    },
+    "files": [
+        "dist-*/**",
+        "runtime/package.json"
+    ]
+}