@aws-sdk/client-gamelift 3.32.0 → 3.36.0

package/dist-types/commands/CreateFleetCommand.d.ts

@@ -0,0 +1,86 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GameLiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GameLiftClient";
+import { CreateFleetInput, CreateFleetOutput } from "../models/models_0";
+export interface CreateFleetCommandInput extends CreateFleetInput {
+}
+export interface CreateFleetCommandOutput extends CreateFleetOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates a fleet of Amazon Elastic Compute Cloud (Amazon EC2) instances to host your
+ *             custom game server or Realtime Servers. Use this operation to configure the computing resources for
+ *             your fleet and provide instructions for running game servers on each instance.</p>
+ *         <p>Most GameLift fleets can deploy instances to multiple locations, including the home
+ *             Region (where the fleet is created) and an optional set of remote locations. Fleets that
+ *             are created in the following AWS Regions support multiple locations: us-east-1 (N.
+ *             Virginia), us-west-2 (Oregon), eu-central-1 (Frankfurt), eu-west-1 (Ireland),
+ *             ap-southeast-2 (Sydney), ap-northeast-1 (Tokyo), and ap-northeast-2 (Seoul). Fleets that
+ *             are created in other GameLift Regions can deploy instances in the fleet's home Region
+ *             only. All fleet instances use the same configuration regardless of location; however,
+ *             you can adjust capacity settings and turn auto-scaling on/off for each location.</p>
+ *         <p>To create a fleet, choose the hardware for your instances, specify a game server build
+ *             or Realtime script to deploy, and provide a runtime configuration to direct GameLift how
+ *             to start and run game servers on each instance in the fleet. Set permissions for inbound
+ *             traffic to your game servers, and enable optional features as needed. When creating a
+ *             multi-location fleet, provide a list of additional remote locations.</p>
+ *
+ *         <p>If successful, this operation creates a new Fleet resource and places it in
+ *                 <code>NEW</code> status, which prompts GameLift to initiate the <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creation-workflow.html">fleet creation
+ *                 workflow</a>. You can track fleet creation by checking fleet status using <a>DescribeFleetAttributes</a> and <a>DescribeFleetLocationAttributes</a>/, or by monitoring fleet creation events
+ *             using <a>DescribeFleetEvents</a>. As soon as the fleet status changes to
+ *                 <code>ACTIVE</code>, you can enable automatic scaling for the fleet with <a>PutScalingPolicy</a> and set capacity for the home Region with <a>UpdateFleetCapacity</a>. When the status of each remote location reaches
+ *                 <code>ACTIVE</code>, you can set capacity by location using <a>UpdateFleetCapacity</a>.</p>
+ *
+ *
+ *         <p>
+ *             <b>Learn more</b>
+ *          </p>
+ *         <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html">Setting up fleets</a>
+ *          </p>
+ *         <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-creating-debug.html#fleets-creating-debug-creation">Debug fleet creation issues</a>
+ *          </p>
+ *         <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html">Multi-location fleets</a>
+ *          </p>
+ *         <p>
+ *             <b>Related actions</b>
+ *          </p>
+ *                     <p>
+ *             <a>CreateFleet</a> |
+ *                     <a>UpdateFleetCapacity</a> |
+ *                     <a>PutScalingPolicy</a> |
+ *                     <a>DescribeEC2InstanceLimits</a> |
+ *                     <a>DescribeFleetAttributes</a> |
+ *                     <a>DescribeFleetLocationAttributes</a> |
+ *                     <a>UpdateFleetAttributes</a> |
+ *                     <a>StopFleetActions</a> |
+ *                     <a>DeleteFleet</a> |
+ *                     <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets">All APIs by task</a>
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GameLiftClient, CreateFleetCommand } from "@aws-sdk/client-gamelift"; // ES Modules import
+ * // const { GameLiftClient, CreateFleetCommand } = require("@aws-sdk/client-gamelift"); // CommonJS import
+ * const client = new GameLiftClient(config);
+ * const command = new CreateFleetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateFleetCommandInput} for command's `input` shape.
+ * @see {@link CreateFleetCommandOutput} for command's `response` shape.
+ * @see {@link GameLiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateFleetCommand extends $Command<CreateFleetCommandInput, CreateFleetCommandOutput, GameLiftClientResolvedConfig> {
+    readonly input: CreateFleetCommandInput;
+    constructor(input: CreateFleetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GameLiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFleetCommandInput, CreateFleetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateFleetLocationsCommand.d.ts

@@ -0,0 +1,77 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GameLiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GameLiftClient";
+import { CreateFleetLocationsInput, CreateFleetLocationsOutput } from "../models/models_0";
+export interface CreateFleetLocationsCommandInput extends CreateFleetLocationsInput {
+}
+export interface CreateFleetLocationsCommandOutput extends CreateFleetLocationsOutput, __MetadataBearer {
+}
+/**
+ * <p>Adds remote locations to a fleet and begins populating the new locations with EC2
+ *             instances. The new instances conform to the fleet's instance type, auto-scaling, and
+ *             other configuration settings. </p>
+ *         <note>
+ *             <p>This operation cannot be used with fleets that don't support remote locations. Fleets
+ *                 can have multiple locations only if they reside in AWS Regions that support this
+ *                 feature (see <a>CreateFleet</a> for the complete list) and were created
+ *                 after the feature was released in March 2021.</p>
+ *         </note>
+ *         <p>To add fleet locations, specify the fleet to be updated and provide a list of one or
+ *             more locations. </p>
+ *         <p>If successful, this operation returns the list of added locations with their status set
+ *             to <code>NEW</code>. GameLift initiates the process of starting an instance in each added
+ *             location. You can track the status of each new location by monitoring location creation
+ *             events using <a>DescribeFleetEvents</a>. Alternatively, you can poll location
+ *             status by calling <a>DescribeFleetLocationAttributes</a>. After a location
+ *             status becomes <code>ACTIVE</code>, you can adjust the location's capacity as needed
+ *             with <a>UpdateFleetCapacity</a>.</p>
+ *         <p>
+ *             <b>Learn more</b>
+ *          </p>
+ *         <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html">Setting up fleets</a>
+ *          </p>
+ *         <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/fleets-intro.html">Multi-location fleets</a>
+ *          </p>
+ *         <p>
+ *             <b>Related actions</b>
+ *          </p>
+ *                     <p>
+ *             <a>CreateFleetLocations</a> |
+ *                     <a>DescribeFleetLocationAttributes</a> |
+ *                     <a>DescribeFleetLocationCapacity</a> |
+ *                     <a>DescribeFleetLocationUtilization</a> |
+ *                     <a>DescribeFleetAttributes</a> |
+ *                     <a>DescribeFleetCapacity</a> |
+ *                     <a>DescribeFleetUtilization</a> |
+ *                     <a>UpdateFleetCapacity</a> |
+ *                     <a>StopFleetActions</a> |
+ *                     <a>DeleteFleetLocations</a> |
+ *                     <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets">All APIs by task</a>
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GameLiftClient, CreateFleetLocationsCommand } from "@aws-sdk/client-gamelift"; // ES Modules import
+ * // const { GameLiftClient, CreateFleetLocationsCommand } = require("@aws-sdk/client-gamelift"); // CommonJS import
+ * const client = new GameLiftClient(config);
+ * const command = new CreateFleetLocationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateFleetLocationsCommandInput} for command's `input` shape.
+ * @see {@link CreateFleetLocationsCommandOutput} for command's `response` shape.
+ * @see {@link GameLiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateFleetLocationsCommand extends $Command<CreateFleetLocationsCommandInput, CreateFleetLocationsCommandOutput, GameLiftClientResolvedConfig> {
+    readonly input: CreateFleetLocationsCommandInput;
+    constructor(input: CreateFleetLocationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GameLiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateFleetLocationsCommandInput, CreateFleetLocationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateGameServerGroupCommand.d.ts

@@ -0,0 +1,88 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GameLiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GameLiftClient";
+import { CreateGameServerGroupInput, CreateGameServerGroupOutput } from "../models/models_0";
+export interface CreateGameServerGroupCommandInput extends CreateGameServerGroupInput {
+}
+export interface CreateGameServerGroupCommandOutput extends CreateGameServerGroupOutput, __MetadataBearer {
+}
+/**
+ * <p>
+ *             <b>This operation is used with the GameLift FleetIQ solution and game server groups.</b>
+ *          </p>
+ *         <p>Creates a GameLift FleetIQ game server group for managing game hosting on a collection of
+ *             Amazon EC2 instances for game hosting. This operation creates the game server group,
+ *             creates an Auto Scaling group in your AWS account, and establishes a link between the
+ *             two groups. You can view the status of your game server groups in the GameLift console.
+ *             Game server group metrics and events are emitted to Amazon CloudWatch.</p>
+ *         <p>Before creating a new game server group, you must have the following: </p>
+ *         <ul>
+ *             <li>
+ *                 <p>An Amazon EC2 launch template that specifies how to launch Amazon EC2 instances
+ *                     with your game server build. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html"> Launching an Instance from a Launch Template</a> in the
+ *                         <i>Amazon EC2 User Guide</i>. </p>
+ *             </li>
+ *             <li>
+ *                <p>An IAM role that extends limited access to your AWS account to allow GameLift FleetIQ to create and
+ *                     interact with the Auto Scaling group. For more information, see <a href="https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-iam-permissions-roles.html">Create IAM roles for cross-service interaction</a> in the <i>GameLift FleetIQ Developer
+ *                         Guide</i>.</p>
+ *             </li>
+ *          </ul>
+ *         <p>To create a new game server group, specify a unique group name, IAM role and Amazon EC2
+ *             launch template, and provide a list of instance types that can be used in the group. You
+ *             must also set initial maximum and minimum limits on the group's instance count. You can
+ *             optionally set an Auto Scaling policy with target tracking based on a GameLift FleetIQ
+ *             metric.</p>
+ *         <p>Once the game server group and corresponding Auto Scaling group are created, you have
+ *             full access to change the Auto Scaling group's configuration as needed. Several
+ *             properties that are set when creating a game server group, including maximum/minimum
+ *             size and auto-scaling policy settings, must be updated directly in the Auto Scaling
+ *             group. Keep in mind that some Auto Scaling group properties are periodically updated by
+ *             GameLift FleetIQ as part of its balancing activities to optimize for availability and
+ *             cost.</p>
+ *         <p>
+ *             <b>Learn more</b>
+ *          </p>
+ *         <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/gsg-intro.html">GameLift FleetIQ Guide</a>
+ *         </p>
+ *
+ *         <p>
+ *             <b>Related actions</b>
+ *          </p>
+ *                     <p>
+ *             <a>CreateGameServerGroup</a> |
+ *                     <a>ListGameServerGroups</a> |
+ *                     <a>DescribeGameServerGroup</a> |
+ *                     <a>UpdateGameServerGroup</a> |
+ *                     <a>DeleteGameServerGroup</a> |
+ *                     <a>ResumeGameServerGroup</a> |
+ *                     <a>SuspendGameServerGroup</a> |
+ *                     <a>DescribeGameServerInstances</a> |
+ *                     <a href="https://docs.aws.amazon.com/gamelift/latest/fleetiqguide/reference-awssdk-fleetiq.html">All APIs by task</a>
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GameLiftClient, CreateGameServerGroupCommand } from "@aws-sdk/client-gamelift"; // ES Modules import
+ * // const { GameLiftClient, CreateGameServerGroupCommand } = require("@aws-sdk/client-gamelift"); // CommonJS import
+ * const client = new GameLiftClient(config);
+ * const command = new CreateGameServerGroupCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateGameServerGroupCommandInput} for command's `input` shape.
+ * @see {@link CreateGameServerGroupCommandOutput} for command's `response` shape.
+ * @see {@link GameLiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateGameServerGroupCommand extends $Command<CreateGameServerGroupCommandInput, CreateGameServerGroupCommandOutput, GameLiftClientResolvedConfig> {
+    readonly input: CreateGameServerGroupCommandInput;
+    constructor(input: CreateGameServerGroupCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GameLiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGameServerGroupCommandInput, CreateGameServerGroupCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateGameSessionCommand.d.ts

@@ -0,0 +1,88 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GameLiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GameLiftClient";
+import { CreateGameSessionInput, CreateGameSessionOutput } from "../models/models_0";
+export interface CreateGameSessionCommandInput extends CreateGameSessionInput {
+}
+export interface CreateGameSessionCommandOutput extends CreateGameSessionOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates a multiplayer game session for players in a specific fleet location. This
+ *             operation prompts an available server process to start a game session and retrieves
+ *             connection information for the new game session. As an alternative, consider using the
+ *             GameLift game session placement feature with </p>
+ *         <p>with <a>StartGameSessionPlacement</a>, which uses FleetIQ algorithms and
+ *             queues to optimize the placement process.</p>
+ *         <p>When creating a game session, you specify exactly where you want to place it and
+ *             provide a set of game session configuration settings. The fleet must be in
+ *                 <code>ACTIVE</code> status before a game session can be created in it. </p>
+ *         <p>This operation can be used in the following ways: </p>
+ *         <ul>
+ *             <li>
+ *                 <p>To create a game session on an instance in a fleet's home Region, provide a
+ *                     fleet or alias ID along with your game session configuration. </p>
+ *             </li>
+ *             <li>
+ *                 <p>To create a game session on an instance in a fleet's remote location, provide
+ *                     a fleet or alias ID and a location name, along with your game session
+ *                     configuration. </p>
+ *             </li>
+ *          </ul>
+ *         <p>If successful, a workflow is initiated to start a new game session. A
+ *                 <code>GameSession</code> object is returned containing the game session
+ *             configuration and status. When the status is <code>ACTIVE</code>, game session
+ *             connection information is provided and player sessions can be created for the game
+ *             session. By default, newly created game sessions are open to new players. You can
+ *             restrict new player access by using <a>UpdateGameSession</a> to change the
+ *             game session's player session creation policy.</p>
+ *         <p>Game session logs are retained for all active game sessions for 14 days. To access the
+ *             logs, call <a>GetGameSessionLogUrl</a> to download the log files.</p>
+ *         <p>
+ *             <i>Available in GameLift Local.</i>
+ *          </p>
+ *         <p>
+ *             <b>Learn more</b>
+ *          </p>
+ *         <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession">Start a game session</a>
+ *          </p>
+ *         <p>
+ *             <b>Related actions</b>
+ *          </p>
+ *                     <p>
+ *             <a>CreateGameSession</a> |
+ *                     <a>DescribeGameSessions</a> |
+ *                     <a>DescribeGameSessionDetails</a> |
+ *                     <a>SearchGameSessions</a> |
+ *                     <a>UpdateGameSession</a> |
+ *                     <a>GetGameSessionLogUrl</a> |
+ *                     <a>StartGameSessionPlacement</a> |
+ *                     <a>DescribeGameSessionPlacement</a> |
+ *                     <a>StopGameSessionPlacement</a> |
+ *                     <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets">All APIs by task</a>
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GameLiftClient, CreateGameSessionCommand } from "@aws-sdk/client-gamelift"; // ES Modules import
+ * // const { GameLiftClient, CreateGameSessionCommand } = require("@aws-sdk/client-gamelift"); // CommonJS import
+ * const client = new GameLiftClient(config);
+ * const command = new CreateGameSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateGameSessionCommandInput} for command's `input` shape.
+ * @see {@link CreateGameSessionCommandOutput} for command's `response` shape.
+ * @see {@link GameLiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateGameSessionCommand extends $Command<CreateGameSessionCommandInput, CreateGameSessionCommandOutput, GameLiftClientResolvedConfig> {
+    readonly input: CreateGameSessionCommandInput;
+    constructor(input: CreateGameSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GameLiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGameSessionCommandInput, CreateGameSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateGameSessionQueueCommand.d.ts

@@ -0,0 +1,78 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GameLiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GameLiftClient";
+import { CreateGameSessionQueueInput, CreateGameSessionQueueOutput } from "../models/models_0";
+export interface CreateGameSessionQueueCommandInput extends CreateGameSessionQueueInput {
+}
+export interface CreateGameSessionQueueCommandOutput extends CreateGameSessionQueueOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates a placement queue that processes requests for new game sessions. A queue uses
+ *             FleetIQ algorithms to determine the best placement locations and find an
+ *             available game server there, then prompts the game server process to start a new game
+ *             session. </p>
+ *         <p>A game session queue is configured with a set of destinations (GameLift fleets or
+ *             aliases), which determine the locations where the queue can place new game sessions.
+ *             These destinations can span multiple fleet types (Spot and On-Demand), instance types,
+ *             and AWS Regions. If the queue includes multi-location fleets, the queue is able to place
+ *             game sessions in all of a fleet's remote locations. You can opt to filter out individual
+ *             locations if needed.</p>
+ *         <p>The queue configuration also determines how FleetIQ selects the best available placement
+ *             for a new game session. Before searching for an available game server, FleetIQ first
+ *             prioritizes the queue's destinations and locations, with the best placement locations on
+ *             top. You can set up the queue to use the FleetIQ default prioritization or provide an
+ *             alternate set of priorities.</p>
+ *         <p>To create a new queue, provide a name, timeout value, and a list of destinations.
+ *             Optionally, specify a sort configuration and/or a filter, and define a set of latency
+ *             cap policies. You can also include the ARN for an Amazon Simple Notification Service
+ *             (SNS) topic to receive notifications of game session placement activity. Notifications
+ *             using SNS or CloudWatch events is the preferred way to track placement activity.</p>
+ *         <p>If successful, a new <code>GameSessionQueue</code> object is returned with an assigned
+ *             queue ARN. New game session requests, which are submitted to the  queue with <a>StartGameSessionPlacement</a> or <a>StartMatchmaking</a>,
+ *             reference a queue's name or ARN. </p>
+ *         <p>
+ *             <b>Learn more</b>
+ *          </p>
+ *         <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-design.html">
+ *             Design a game session queue</a>
+ *         </p>
+ *         <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-creating.html">
+ *             Create a game session queue</a>
+ *         </p>
+ *         <p>
+ *             <b>Related actions</b>
+ *          </p>
+ *                     <p>
+ *             <a>CreateGameSessionQueue</a> |
+ *                     <a>DescribeGameSessionQueues</a> |
+ *                     <a>UpdateGameSessionQueue</a> |
+ *                     <a>DeleteGameSessionQueue</a> |
+ *                     <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets">All APIs by task</a>
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GameLiftClient, CreateGameSessionQueueCommand } from "@aws-sdk/client-gamelift"; // ES Modules import
+ * // const { GameLiftClient, CreateGameSessionQueueCommand } = require("@aws-sdk/client-gamelift"); // CommonJS import
+ * const client = new GameLiftClient(config);
+ * const command = new CreateGameSessionQueueCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateGameSessionQueueCommandInput} for command's `input` shape.
+ * @see {@link CreateGameSessionQueueCommandOutput} for command's `response` shape.
+ * @see {@link GameLiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateGameSessionQueueCommand extends $Command<CreateGameSessionQueueCommandInput, CreateGameSessionQueueCommandOutput, GameLiftClientResolvedConfig> {
+    readonly input: CreateGameSessionQueueCommandInput;
+    constructor(input: CreateGameSessionQueueCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GameLiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateGameSessionQueueCommandInput, CreateGameSessionQueueCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateMatchmakingConfigurationCommand.d.ts

@@ -0,0 +1,76 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GameLiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GameLiftClient";
+import { CreateMatchmakingConfigurationInput, CreateMatchmakingConfigurationOutput } from "../models/models_0";
+export interface CreateMatchmakingConfigurationCommandInput extends CreateMatchmakingConfigurationInput {
+}
+export interface CreateMatchmakingConfigurationCommandOutput extends CreateMatchmakingConfigurationOutput, __MetadataBearer {
+}
+/**
+ * <p>Defines a new matchmaking configuration for use with FlexMatch. Whether your are using
+ *             FlexMatch with GameLift hosting or as a standalone matchmaking service, the matchmaking
+ *             configuration sets out rules for matching players and forming teams. If you're also
+ *             using GameLift hosting, it defines how to start game sessions for each match. Your
+ *             matchmaking system can use multiple configurations to handle different game scenarios.
+ *             All matchmaking requests (<a>StartMatchmaking</a> or <a>StartMatchBackfill</a>) identify the matchmaking configuration to use and
+ *             provide player attributes consistent with that configuration. </p>
+ *         <p>To create a matchmaking configuration, you must provide the following: configuration
+ *             name and FlexMatch mode (with or without GameLift hosting); a rule set that specifies how
+ *             to evaluate players and find acceptable matches; whether player acceptance is required;
+ *             and the maximum time allowed for a matchmaking attempt. When using FlexMatch with GameLift
+ *             hosting, you also need to identify the game session queue to use when starting a game
+ *             session for the match.</p>
+ *         <p>In addition, you must set up an Amazon Simple Notification Service (SNS) topic to receive matchmaking notifications.
+ *             Provide the topic ARN in the matchmaking configuration. An alternative method,
+ *             continuously polling ticket status with <a>DescribeMatchmaking</a>, is only
+ *             suitable for games in development with low matchmaking usage.</p>
+ *         <p>
+ *             <b>Learn more</b>
+ *          </p>
+ *         <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-configuration.html">
+ *                 Design a FlexMatch matchmaker</a>
+ *          </p>
+ *         <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-notification.html">
+ *             Set up FlexMatch event notification</a>
+ *          </p>
+ *         <p>
+ *             <b>Related actions</b>
+ *          </p>
+ *                     <p>
+ *             <a>CreateMatchmakingConfiguration</a> |
+ *                     <a>DescribeMatchmakingConfigurations</a> |
+ *                     <a>UpdateMatchmakingConfiguration</a> |
+ *                     <a>DeleteMatchmakingConfiguration</a> |
+ *                     <a>CreateMatchmakingRuleSet</a> |
+ *                     <a>DescribeMatchmakingRuleSets</a> |
+ *                     <a>ValidateMatchmakingRuleSet</a> |
+ *                     <a>DeleteMatchmakingRuleSet</a> |
+ *                     <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets">All APIs by task</a>
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GameLiftClient, CreateMatchmakingConfigurationCommand } from "@aws-sdk/client-gamelift"; // ES Modules import
+ * // const { GameLiftClient, CreateMatchmakingConfigurationCommand } = require("@aws-sdk/client-gamelift"); // CommonJS import
+ * const client = new GameLiftClient(config);
+ * const command = new CreateMatchmakingConfigurationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateMatchmakingConfigurationCommandInput} for command's `input` shape.
+ * @see {@link CreateMatchmakingConfigurationCommandOutput} for command's `response` shape.
+ * @see {@link GameLiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateMatchmakingConfigurationCommand extends $Command<CreateMatchmakingConfigurationCommandInput, CreateMatchmakingConfigurationCommandOutput, GameLiftClientResolvedConfig> {
+    readonly input: CreateMatchmakingConfigurationCommandInput;
+    constructor(input: CreateMatchmakingConfigurationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GameLiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMatchmakingConfigurationCommandInput, CreateMatchmakingConfigurationCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreateMatchmakingRuleSetCommand.d.ts

@@ -0,0 +1,81 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GameLiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GameLiftClient";
+import { CreateMatchmakingRuleSetInput, CreateMatchmakingRuleSetOutput } from "../models/models_0";
+export interface CreateMatchmakingRuleSetCommandInput extends CreateMatchmakingRuleSetInput {
+}
+export interface CreateMatchmakingRuleSetCommandOutput extends CreateMatchmakingRuleSetOutput, __MetadataBearer {
+}
+/**
+ * <p>Creates a new rule set for FlexMatch matchmaking. A rule set describes the type of match
+ *             to create, such as the number and size of teams. It also sets the parameters for
+ *             acceptable player matches, such as minimum skill level or character type. A rule set is
+ *             used by a <a>MatchmakingConfiguration</a>. </p>
+ *         <p>To create a matchmaking rule set, provide unique rule set name and the rule set body
+ *             in JSON format. Rule sets must be defined in the same Region as the matchmaking
+ *             configuration they are used with.</p>
+ *         <p>Since matchmaking rule sets cannot be edited, it is a good idea to check the rule
+ *             set syntax using <a>ValidateMatchmakingRuleSet</a> before creating a new rule
+ *             set.</p>
+ *         <p>
+ *             <b>Learn more</b>
+ *          </p>
+ *         <ul>
+ *             <li>
+ *                 <p>
+ *                   <a href="https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-rulesets.html">Build a rule
+ *                         set</a>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <a href="https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-configuration.html">Design a
+ *                         matchmaker</a>
+ *                </p>
+ *             </li>
+ *             <li>
+ *                 <p>
+ *                   <a href="https://docs.aws.amazon.com/gamelift/latest/flexmatchguide/match-intro.html">Matchmaking with
+ *                         FlexMatch</a>
+ *                </p>
+ *             </li>
+ *          </ul>
+ *         <p>
+ *             <b>Related actions</b>
+ *          </p>
+ *                     <p>
+ *             <a>CreateMatchmakingConfiguration</a> |
+ *                     <a>DescribeMatchmakingConfigurations</a> |
+ *                     <a>UpdateMatchmakingConfiguration</a> |
+ *                     <a>DeleteMatchmakingConfiguration</a> |
+ *                     <a>CreateMatchmakingRuleSet</a> |
+ *                     <a>DescribeMatchmakingRuleSets</a> |
+ *                     <a>ValidateMatchmakingRuleSet</a> |
+ *                     <a>DeleteMatchmakingRuleSet</a> |
+ *                     <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets">All APIs by task</a>
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GameLiftClient, CreateMatchmakingRuleSetCommand } from "@aws-sdk/client-gamelift"; // ES Modules import
+ * // const { GameLiftClient, CreateMatchmakingRuleSetCommand } = require("@aws-sdk/client-gamelift"); // CommonJS import
+ * const client = new GameLiftClient(config);
+ * const command = new CreateMatchmakingRuleSetCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateMatchmakingRuleSetCommandInput} for command's `input` shape.
+ * @see {@link CreateMatchmakingRuleSetCommandOutput} for command's `response` shape.
+ * @see {@link GameLiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreateMatchmakingRuleSetCommand extends $Command<CreateMatchmakingRuleSetCommandInput, CreateMatchmakingRuleSetCommandOutput, GameLiftClientResolvedConfig> {
+    readonly input: CreateMatchmakingRuleSetCommandInput;
+    constructor(input: CreateMatchmakingRuleSetCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GameLiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateMatchmakingRuleSetCommandInput, CreateMatchmakingRuleSetCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/CreatePlayerSessionCommand.d.ts

@@ -0,0 +1,58 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { GameLiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GameLiftClient";
+import { CreatePlayerSessionInput, CreatePlayerSessionOutput } from "../models/models_0";
+export interface CreatePlayerSessionCommandInput extends CreatePlayerSessionInput {
+}
+export interface CreatePlayerSessionCommandOutput extends CreatePlayerSessionOutput, __MetadataBearer {
+}
+/**
+ * <p>Reserves an open player slot in a game session for a player. New player sessions can be
+ *             created in any game session with an open slot that is in <code>ACTIVE</code> status and
+ *             has a player creation policy of <code>ACCEPT_ALL</code>. You can add a group of players
+ *             to a game session with <a>CreatePlayerSessions</a>. </p>
+ *          <p>To create a player session, specify a game session ID, player ID, and optionally a set of
+ *             player data. </p>
+ *         <p>If successful, a slot is reserved in the game session for the player and a new <a>PlayerSession</a> object is returned with a player session ID. The player
+ *             references the player session ID when sending a connection request to the game session,
+ *             and the game server can use it to validate the player reservation with the GameLift service. Player
+ *             sessions cannot be updated. </p>
+ *          <p>
+ *             <i>Available in Amazon GameLift Local.</i>
+ *          </p>
+ *          <p>
+ *             <b>Related actions</b>
+ *          </p>
+ *                     <p>
+ *             <a>CreatePlayerSession</a> |
+ *                     <a>CreatePlayerSessions</a> |
+ *                     <a>DescribePlayerSessions</a> |
+ *                     <a>StartGameSessionPlacement</a> |
+ *                     <a>DescribeGameSessionPlacement</a> |
+ *                     <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/reference-awssdk.html#reference-awssdk-resources-fleets">All APIs by task</a>
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { GameLiftClient, CreatePlayerSessionCommand } from "@aws-sdk/client-gamelift"; // ES Modules import
+ * // const { GameLiftClient, CreatePlayerSessionCommand } = require("@aws-sdk/client-gamelift"); // CommonJS import
+ * const client = new GameLiftClient(config);
+ * const command = new CreatePlayerSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreatePlayerSessionCommandInput} for command's `input` shape.
+ * @see {@link CreatePlayerSessionCommandOutput} for command's `response` shape.
+ * @see {@link GameLiftClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class CreatePlayerSessionCommand extends $Command<CreatePlayerSessionCommandInput, CreatePlayerSessionCommandOutput, GameLiftClientResolvedConfig> {
+    readonly input: CreatePlayerSessionCommandInput;
+    constructor(input: CreatePlayerSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: GameLiftClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreatePlayerSessionCommandInput, CreatePlayerSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}