@anweather/game-plugin-ssdk 1.2.0

package/dist-types/src/models/models_0.d.ts

@@ -0,0 +1,402 @@
+import { ServiceException as __BaseException, ValidationFailure as __ValidationFailure } from "@aws-smithy/server-common";
+import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { DocumentType as __DocumentType } from "@smithy/types";
+/**
+ * @public
+ */
+export interface Move {
+    participantId: string | undefined;
+    payload: __DocumentType | undefined;
+    sequenceNumber: number | undefined;
+    timestamp: Date | undefined;
+}
+export declare namespace Move {
+    /**
+     * @internal
+     */
+    const validate: (obj: Move, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface ApplyMoveInput {
+    pluginState: __DocumentType | undefined;
+    move: Move | undefined;
+}
+export declare namespace ApplyMoveInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: ApplyMoveInput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export declare class InvalidMoveError extends __BaseException {
+    readonly name: "InvalidMoveError";
+    readonly $fault: "client";
+    constructor(opts: __ExceptionOptionType<InvalidMoveError, __BaseException>);
+}
+/**
+ * @public
+ */
+export interface PluginStateUpdate {
+    nextTurnParticipantId?: string | undefined;
+    pluginState: __DocumentType | undefined;
+}
+export declare namespace PluginStateUpdate {
+    /**
+     * @internal
+     */
+    const validate: (obj: PluginStateUpdate, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface ApplySaveFileEditInput {
+    profile: __DocumentType | undefined;
+    edit: __DocumentType | undefined;
+}
+export declare namespace ApplySaveFileEditInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: ApplySaveFileEditInput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface ApplySaveFileEditOutput {
+    profile: __DocumentType | undefined;
+    state: __DocumentType | undefined;
+}
+export declare namespace ApplySaveFileEditOutput {
+    /**
+     * @internal
+     */
+    const validate: (obj: ApplySaveFileEditOutput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export declare class SaveFileEditRejectedError extends __BaseException {
+    readonly name: "SaveFileEditRejectedError";
+    readonly $fault: "client";
+    reason: string | undefined;
+    constructor(opts: __ExceptionOptionType<SaveFileEditRejectedError, __BaseException>);
+}
+/**
+ * @public
+ */
+export interface AssignParticipantsInput {
+    participants: (string)[] | undefined;
+    config?: __DocumentType | undefined;
+}
+export declare namespace AssignParticipantsInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: AssignParticipantsInput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface AssignParticipantsOutput {
+    participants: (string)[] | undefined;
+}
+export declare namespace AssignParticipantsOutput {
+    /**
+     * @internal
+     */
+    const validate: (obj: AssignParticipantsOutput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface BotSkillLevelEntry {
+    id: string | undefined;
+    displayName: string | undefined;
+}
+export declare namespace BotSkillLevelEntry {
+    /**
+     * @internal
+     */
+    const validate: (obj: BotSkillLevelEntry, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface DescribeSaveFileInput {
+    profile: __DocumentType | undefined;
+}
+export declare namespace DescribeSaveFileInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: DescribeSaveFileInput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface DescribeSaveFileOutput {
+    summary?: string | undefined;
+}
+export declare namespace DescribeSaveFileOutput {
+    /**
+     * @internal
+     */
+    const validate: (obj: DescribeSaveFileOutput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const Outcome: {
+    readonly ABANDONED: "ABANDONED";
+    readonly DRAW: "DRAW";
+    readonly WIN: "WIN";
+};
+/**
+ * @public
+ */
+export type Outcome = typeof Outcome[keyof typeof Outcome];
+/**
+ * @public
+ */
+export interface GameResultOutput {
+    outcome?: Outcome | undefined;
+    winners?: (string)[] | undefined;
+}
+export declare namespace GameResultOutput {
+    /**
+     * @internal
+     */
+    const validate: (obj: GameResultOutput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface PluginStateOnlyInput {
+    pluginState: __DocumentType | undefined;
+}
+export declare namespace PluginStateOnlyInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: PluginStateOnlyInput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface GameStatusOutput {
+    isGameOver: boolean | undefined;
+}
+export declare namespace GameStatusOutput {
+    /**
+     * @internal
+     */
+    const validate: (obj: GameStatusOutput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface GameTypeMetadata {
+    id: string | undefined;
+    minPlayers: number | undefined;
+    maxPlayers: number | undefined;
+    displayName?: string | undefined;
+    hasBotStrategy: boolean | undefined;
+    teamPlay: boolean | undefined;
+    spectatorSafe: boolean | undefined;
+    configSchema?: __DocumentType | undefined;
+    botSkillLevels?: (BotSkillLevelEntry)[] | undefined;
+    hasConfigMove?: boolean | undefined;
+    hasOutOfTurnMove?: boolean | undefined;
+    hasCustomPlayerView?: boolean | undefined;
+    hasSaveFiles?: boolean | undefined;
+    hasSaveSummary?: boolean | undefined;
+    hasSaveFileEditor?: boolean | undefined;
+}
+export declare namespace GameTypeMetadata {
+    /**
+     * @internal
+     */
+    const validate: (obj: GameTypeMetadata, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface GetPlayerViewInput {
+    pluginState: __DocumentType | undefined;
+    participantId: string | undefined;
+}
+export declare namespace GetPlayerViewInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: GetPlayerViewInput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface GetPlayerViewOutput {
+    pluginState: __DocumentType | undefined;
+}
+export declare namespace GetPlayerViewOutput {
+    /**
+     * @internal
+     */
+    const validate: (obj: GetPlayerViewOutput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface GetSaveFileEditorStateInput {
+    profile: __DocumentType | undefined;
+}
+export declare namespace GetSaveFileEditorStateInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: GetSaveFileEditorStateInput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface GetSaveFileEditorStateOutput {
+    state: __DocumentType | undefined;
+}
+export declare namespace GetSaveFileEditorStateOutput {
+    /**
+     * @internal
+     */
+    const validate: (obj: GetSaveFileEditorStateOutput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface HealthOutput {
+    status: string | undefined;
+    gameType: string | undefined;
+    protocolVersion: number | undefined;
+}
+export declare namespace HealthOutput {
+    /**
+     * @internal
+     */
+    const validate: (obj: HealthOutput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface InitializeGameInput {
+    config?: __DocumentType | undefined;
+    participants: (string)[] | undefined;
+}
+export declare namespace InitializeGameInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: InitializeGameInput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface IsConfigMoveInput {
+    payload: __DocumentType | undefined;
+}
+export declare namespace IsConfigMoveInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: IsConfigMoveInput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface IsConfigMoveOutput {
+    isConfigMove: boolean | undefined;
+}
+export declare namespace IsConfigMoveOutput {
+    /**
+     * @internal
+     */
+    const validate: (obj: IsConfigMoveOutput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface IsOutOfTurnMoveInput {
+    payload: __DocumentType | undefined;
+}
+export declare namespace IsOutOfTurnMoveInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: IsOutOfTurnMoveInput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface IsOutOfTurnMoveOutput {
+    isOutOfTurnMove: boolean | undefined;
+}
+export declare namespace IsOutOfTurnMoveOutput {
+    /**
+     * @internal
+     */
+    const validate: (obj: IsOutOfTurnMoveOutput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface SelectBotMoveInput {
+    pluginState: __DocumentType | undefined;
+    participantId: string | undefined;
+    skillLevel?: string | undefined;
+}
+export declare namespace SelectBotMoveInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: SelectBotMoveInput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface SelectBotMoveOutput {
+    payload: __DocumentType | undefined;
+}
+export declare namespace SelectBotMoveOutput {
+    /**
+     * @internal
+     */
+    const validate: (obj: SelectBotMoveOutput, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface MoveValidation {
+    valid: boolean | undefined;
+    reason?: string | undefined;
+}
+export declare namespace MoveValidation {
+    /**
+     * @internal
+     */
+    const validate: (obj: MoveValidation, path?: string) => __ValidationFailure[];
+}
+/**
+ * @public
+ */
+export interface ValidateMoveInput {
+    pluginState: __DocumentType | undefined;
+    move: Move | undefined;
+    participantId: string | undefined;
+}
+export declare namespace ValidateMoveInput {
+    /**
+     * @internal
+     */
+    const validate: (obj: ValidateMoveInput, path?: string) => __ValidationFailure[];
+}

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

@@ -0,0 +1,52 @@
+import { InvalidMoveError, SaveFileEditRejectedError } from "../models/models_0";
+import { ApplyMoveServerInput, ApplyMoveServerOutput } from "../server/operations/ApplyMove";
+import { ApplySaveFileEditServerInput, ApplySaveFileEditServerOutput } from "../server/operations/ApplySaveFileEdit";
+import { AssignParticipantsServerInput, AssignParticipantsServerOutput } from "../server/operations/AssignParticipants";
+import { DescribeSaveFileServerInput, DescribeSaveFileServerOutput } from "../server/operations/DescribeSaveFile";
+import { GetGameResultServerInput, GetGameResultServerOutput } from "../server/operations/GetGameResult";
+import { GetGameStatusServerInput, GetGameStatusServerOutput } from "../server/operations/GetGameStatus";
+import { GetMetadataServerInput, GetMetadataServerOutput } from "../server/operations/GetMetadata";
+import { GetPlayerViewServerInput, GetPlayerViewServerOutput } from "../server/operations/GetPlayerView";
+import { GetSaveFileEditorStateServerInput, GetSaveFileEditorStateServerOutput } from "../server/operations/GetSaveFileEditorState";
+import { HealthServerInput, HealthServerOutput } from "../server/operations/Health";
+import { InitializeGameServerInput, InitializeGameServerOutput } from "../server/operations/InitializeGame";
+import { IsConfigMoveServerInput, IsConfigMoveServerOutput } from "../server/operations/IsConfigMove";
+import { IsOutOfTurnMoveServerInput, IsOutOfTurnMoveServerOutput } from "../server/operations/IsOutOfTurnMove";
+import { SelectBotMoveServerInput, SelectBotMoveServerOutput } from "../server/operations/SelectBotMove";
+import { ValidateMoveServerInput, ValidateMoveServerOutput } from "../server/operations/ValidateMove";
+import { ServerSerdeContext, SmithyFrameworkException as __SmithyFrameworkException } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+import { SerdeContext as __SerdeContext } from "@smithy/types";
+export declare const deserializeApplyMoveRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<ApplyMoveServerInput>;
+export declare const deserializeApplySaveFileEditRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<ApplySaveFileEditServerInput>;
+export declare const deserializeAssignParticipantsRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<AssignParticipantsServerInput>;
+export declare const deserializeDescribeSaveFileRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<DescribeSaveFileServerInput>;
+export declare const deserializeGetGameResultRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<GetGameResultServerInput>;
+export declare const deserializeGetGameStatusRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<GetGameStatusServerInput>;
+export declare const deserializeGetMetadataRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<GetMetadataServerInput>;
+export declare const deserializeGetPlayerViewRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<GetPlayerViewServerInput>;
+export declare const deserializeGetSaveFileEditorStateRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<GetSaveFileEditorStateServerInput>;
+export declare const deserializeHealthRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<HealthServerInput>;
+export declare const deserializeInitializeGameRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<InitializeGameServerInput>;
+export declare const deserializeIsConfigMoveRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<IsConfigMoveServerInput>;
+export declare const deserializeIsOutOfTurnMoveRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<IsOutOfTurnMoveServerInput>;
+export declare const deserializeSelectBotMoveRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<SelectBotMoveServerInput>;
+export declare const deserializeValidateMoveRequest: (output: __HttpRequest, context: __SerdeContext) => Promise<ValidateMoveServerInput>;
+export declare const serializeApplyMoveResponse: (input: ApplyMoveServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeApplySaveFileEditResponse: (input: ApplySaveFileEditServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeAssignParticipantsResponse: (input: AssignParticipantsServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeDescribeSaveFileResponse: (input: DescribeSaveFileServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeGetGameResultResponse: (input: GetGameResultServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeGetGameStatusResponse: (input: GetGameStatusServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeGetMetadataResponse: (input: GetMetadataServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeGetPlayerViewResponse: (input: GetPlayerViewServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeGetSaveFileEditorStateResponse: (input: GetSaveFileEditorStateServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeHealthResponse: (input: HealthServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeInitializeGameResponse: (input: InitializeGameServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeIsConfigMoveResponse: (input: IsConfigMoveServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeIsOutOfTurnMoveResponse: (input: IsOutOfTurnMoveServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeSelectBotMoveResponse: (input: SelectBotMoveServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeValidateMoveResponse: (input: ValidateMoveServerOutput, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeFrameworkException: (input: __SmithyFrameworkException, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeInvalidMoveErrorError: (input: InvalidMoveError, ctx: ServerSerdeContext) => Promise<__HttpResponse>;
+export declare const serializeSaveFileEditRejectedErrorError: (input: SaveFileEditRejectedError, ctx: ServerSerdeContext) => Promise<__HttpResponse>;

package/dist-types/src/server/GamePluginService.d.ts

@@ -0,0 +1,54 @@
+import { ApplyMove } from "./operations/ApplyMove";
+import { ApplySaveFileEdit } from "./operations/ApplySaveFileEdit";
+import { AssignParticipants } from "./operations/AssignParticipants";
+import { DescribeSaveFile } from "./operations/DescribeSaveFile";
+import { GetGameResult } from "./operations/GetGameResult";
+import { GetGameStatus } from "./operations/GetGameStatus";
+import { GetMetadata } from "./operations/GetMetadata";
+import { GetPlayerView } from "./operations/GetPlayerView";
+import { GetSaveFileEditorState } from "./operations/GetSaveFileEditorState";
+import { Health } from "./operations/Health";
+import { InitializeGame } from "./operations/InitializeGame";
+import { IsConfigMove } from "./operations/IsConfigMove";
+import { IsOutOfTurnMove } from "./operations/IsOutOfTurnMove";
+import { SelectBotMove } from "./operations/SelectBotMove";
+import { ValidateMove } from "./operations/ValidateMove";
+import { Mux as __Mux, OperationSerializer as __OperationSerializer, ServerSerdeContext as __ServerSerdeContext, ServiceException as __ServiceException, ServiceHandler as __ServiceHandler, SmithyFrameworkException as __SmithyFrameworkException, ValidationCustomizer as __ValidationCustomizer } from "@aws-smithy/server-common";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@smithy/protocol-http";
+export type GamePluginServiceOperations = "ApplyMove" | "ApplySaveFileEdit" | "AssignParticipants" | "DescribeSaveFile" | "GetGameResult" | "GetGameStatus" | "GetMetadata" | "GetPlayerView" | "GetSaveFileEditorState" | "Health" | "InitializeGame" | "IsConfigMove" | "IsOutOfTurnMove" | "SelectBotMove" | "ValidateMove";
+export interface GamePluginService<Context> {
+    ApplyMove: ApplyMove<Context>;
+    ApplySaveFileEdit: ApplySaveFileEdit<Context>;
+    AssignParticipants: AssignParticipants<Context>;
+    DescribeSaveFile: DescribeSaveFile<Context>;
+    GetGameResult: GetGameResult<Context>;
+    GetGameStatus: GetGameStatus<Context>;
+    GetMetadata: GetMetadata<Context>;
+    GetPlayerView: GetPlayerView<Context>;
+    GetSaveFileEditorState: GetSaveFileEditorState<Context>;
+    Health: Health<Context>;
+    InitializeGame: InitializeGame<Context>;
+    IsConfigMove: IsConfigMove<Context>;
+    IsOutOfTurnMove: IsOutOfTurnMove<Context>;
+    SelectBotMove: SelectBotMove<Context>;
+    ValidateMove: ValidateMove<Context>;
+}
+export declare class GamePluginServiceHandler<Context> implements __ServiceHandler<Context> {
+    private readonly service;
+    private readonly mux;
+    private readonly serializerFactory;
+    private readonly serializeFrameworkException;
+    private readonly validationCustomizer;
+    /**
+     * Construct a GamePluginService handler.
+     * @param service The {@link GamePluginService} implementation that supplies the business logic for GamePluginService
+     * @param mux The {@link __Mux} that determines which service and operation are being invoked by a given {@link __HttpRequest}
+     * @param serializerFactory A factory for an {@link __OperationSerializer} for each operation in GamePluginService that
+     *                          handles deserialization of requests and serialization of responses
+     * @param serializeFrameworkException A function that can serialize {@link __SmithyFrameworkException}s
+     * @param validationCustomizer A {@link __ValidationCustomizer} for turning validation failures into {@link __SmithyFrameworkException}s
+     */
+    constructor(service: GamePluginService<Context>, mux: __Mux<"GamePlugin", GamePluginServiceOperations>, serializerFactory: <T extends GamePluginServiceOperations>(op: T) => __OperationSerializer<GamePluginService<Context>, T, __ServiceException>, serializeFrameworkException: (e: __SmithyFrameworkException, ctx: __ServerSerdeContext) => Promise<__HttpResponse>, validationCustomizer: __ValidationCustomizer<GamePluginServiceOperations>);
+    handle(request: __HttpRequest, context: Context): Promise<__HttpResponse>;
+}
+export declare const getGamePluginServiceHandler: <Context>(service: GamePluginService<Context>, customizer: __ValidationCustomizer<GamePluginServiceOperations>) => __ServiceHandler<Context, __HttpRequest, __HttpResponse>;

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

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

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

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

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

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

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

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