@aws-sdk/client-gamelift 3.726.1 → 3.728.0

package/dist-cjs/index.js

@@ -220,6 +220,7 @@ __export(src_exports, {
   OperatingSystem: () => OperatingSystem,
   OutOfCapacityException: () => OutOfCapacityException,
   PlacedPlayerSessionFilterSensitiveLog: () => PlacedPlayerSessionFilterSensitiveLog,
+  PlacementFallbackStrategy: () => PlacementFallbackStrategy,
   PlayerFilterSensitiveLog: () => PlayerFilterSensitiveLog,
   PlayerLatencyFilterSensitiveLog: () => PlayerLatencyFilterSensitiveLog,
   PlayerSessionCreationPolicy: () => PlayerSessionCreationPolicy,
@@ -1355,6 +1356,10 @@ var GameServerInstanceStatus = {
   DRAINING: "DRAINING",
   SPOT_TERMINATING: "SPOT_TERMINATING"
 };
+var PlacementFallbackStrategy = {
+  DEFAULT_AFTER_SINGLE_PASS: "DEFAULT_AFTER_SINGLE_PASS",
+  NONE: "NONE"
+};
 var GameSessionPlacementState = {
   CANCELLED: "CANCELLED",
   FAILED: "FAILED",
@@ -1668,12 +1673,6 @@ var ListComputeOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj,
   ...obj.ComputeList && { ComputeList: obj.ComputeList.map((item) => ComputeFilterSensitiveLog(item)) }
 }), "ListComputeOutputFilterSensitiveLog");
-var ListContainerFleetsOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.ContainerFleets && {
-    ContainerFleets: obj.ContainerFleets.map((item) => ContainerFleetFilterSensitiveLog(item))
-  }
-}), "ListContainerFleetsOutputFilterSensitiveLog");
 
 // src/protocols/Aws_json1_1.ts
 var import_core2 = require("@aws-sdk/core");
@@ -4237,7 +4236,8 @@ var se_StartGameSessionPlacementInput = /* @__PURE__ */ __name((input, context)
     GameSessionQueueName: [],
     MaximumPlayerSessionCount: [],
     PlacementId: [],
-    PlayerLatencies: (_) => se_PlayerLatencyList(_, context)
+    PlayerLatencies: (_) => se_PlayerLatencyList(_, context),
+    PriorityConfigurationOverride: import_smithy_client._json
   });
 }, "se_StartGameSessionPlacementInput");
 var se_StartMatchBackfillInput = /* @__PURE__ */ __name((input, context) => {
@@ -4797,6 +4797,7 @@ var de_GameSessionPlacement = /* @__PURE__ */ __name((output, context) => {
     PlacementId: import_smithy_client.expectString,
     PlayerLatencies: (_) => de_PlayerLatencyList(_, context),
     Port: import_smithy_client.expectInt32,
+    PriorityConfigurationOverride: import_smithy_client._json,
     StartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
     Status: import_smithy_client.expectString
   });
@@ -6357,21 +6358,6 @@ var ListComputeCommand = class extends import_smithy_client.Command.classBuilder
 
 
 
-var ListContainerFleetsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
-  return [
-    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
-    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
-  ];
-}).s("GameLift", "ListContainerFleets", {}).n("GameLiftClient", "ListContainerFleetsCommand").f(void 0, ListContainerFleetsOutputFilterSensitiveLog).ser(se_ListContainerFleetsCommand).de(de_ListContainerFleetsCommand).build() {
-  static {
-    __name(this, "ListContainerFleetsCommand");
-  }
-};
-
-// src/commands/ListContainerGroupDefinitionsCommand.ts
-
-
-
 
 // src/models/models_1.ts
 
@@ -6390,6 +6376,12 @@ var TerminationMode = {
 var GameServerHealthCheck = {
   HEALTHY: "HEALTHY"
 };
+var ListContainerFleetsOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.ContainerFleets && {
+    ContainerFleets: obj.ContainerFleets.map((item) => ContainerFleetFilterSensitiveLog(item))
+  }
+}), "ListContainerFleetsOutputFilterSensitiveLog");
 var ListContainerGroupDefinitionsOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
   ...obj
 }), "ListContainerGroupDefinitionsOutputFilterSensitiveLog");
@@ -6495,7 +6487,22 @@ var UpdateGameSessionOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) =>
   ...obj.GameSession && { GameSession: GameSessionFilterSensitiveLog(obj.GameSession) }
 }), "UpdateGameSessionOutputFilterSensitiveLog");
 
+// src/commands/ListContainerFleetsCommand.ts
+var ListContainerFleetsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("GameLift", "ListContainerFleets", {}).n("GameLiftClient", "ListContainerFleetsCommand").f(void 0, ListContainerFleetsOutputFilterSensitiveLog).ser(se_ListContainerFleetsCommand).de(de_ListContainerFleetsCommand).build() {
+  static {
+    __name(this, "ListContainerFleetsCommand");
+  }
+};
+
 // src/commands/ListContainerGroupDefinitionsCommand.ts
+
+
+
 var ListContainerGroupDefinitionsCommand = class extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
   return [
     (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
@@ -7573,6 +7580,7 @@ var paginateSearchGameSessions = (0, import_core.createPaginator)(GameLiftClient
   EventCode,
   LocationUpdateStatus,
   GameServerInstanceStatus,
+  PlacementFallbackStrategy,
   GameSessionPlacementState,
   InstanceStatus,
   MatchmakingConfigurationStatus,
@@ -7633,11 +7641,11 @@ var paginateSearchGameSessions = (0, import_core.createPaginator)(GameLiftClient
   InstanceAccessFilterSensitiveLog,
   GetInstanceAccessOutputFilterSensitiveLog,
   ListComputeOutputFilterSensitiveLog,
-  ListContainerFleetsOutputFilterSensitiveLog,
   SortOrder,
   LocationFilter,
   TerminationMode,
   GameServerHealthCheck,
+  ListContainerFleetsOutputFilterSensitiveLog,
   ListContainerGroupDefinitionsOutputFilterSensitiveLog,
   ListContainerGroupDefinitionVersionsOutputFilterSensitiveLog,
   RegisterComputeInputFilterSensitiveLog,

package/dist-es/commands/ListContainerFleetsCommand.js

@@ -2,7 +2,7 @@ import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
 import { commonParams } from "../endpoint/EndpointParameters";
-import { ListContainerFleetsOutputFilterSensitiveLog, } from "../models/models_0";
+import { ListContainerFleetsOutputFilterSensitiveLog, } from "../models/models_1";
 import { de_ListContainerFleetsCommand, se_ListContainerFleetsCommand } from "../protocols/Aws_json1_1";
 export { $Command };
 export class ListContainerFleetsCommand extends $Command

package/dist-es/models/models_0.js

@@ -769,6 +769,10 @@ export const GameServerInstanceStatus = {
     DRAINING: "DRAINING",
     SPOT_TERMINATING: "SPOT_TERMINATING",
 };
+export const PlacementFallbackStrategy = {
+    DEFAULT_AFTER_SINGLE_PASS: "DEFAULT_AFTER_SINGLE_PASS",
+    NONE: "NONE",
+};
 export const GameSessionPlacementState = {
     CANCELLED: "CANCELLED",
     FAILED: "FAILED",
@@ -1082,9 +1086,3 @@ export const ListComputeOutputFilterSensitiveLog = (obj) => ({
     ...obj,
     ...(obj.ComputeList && { ComputeList: obj.ComputeList.map((item) => ComputeFilterSensitiveLog(item)) }),
 });
-export const ListContainerFleetsOutputFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ContainerFleets && {
-        ContainerFleets: obj.ContainerFleets.map((item) => ContainerFleetFilterSensitiveLog(item)),
-    }),
-});

package/dist-es/models/models_1.js

@@ -15,6 +15,12 @@ export const TerminationMode = {
 export const GameServerHealthCheck = {
     HEALTHY: "HEALTHY",
 };
+export const ListContainerFleetsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ContainerFleets && {
+        ContainerFleets: obj.ContainerFleets.map((item) => ContainerFleetFilterSensitiveLog(item)),
+    }),
+});
 export const ListContainerGroupDefinitionsOutputFilterSensitiveLog = (obj) => ({
     ...obj,
 });

package/dist-es/protocols/Aws_json1_1.js

@@ -2566,6 +2566,7 @@ const se_StartGameSessionPlacementInput = (input, context) => {
         MaximumPlayerSessionCount: [],
         PlacementId: [],
         PlayerLatencies: (_) => se_PlayerLatencyList(_, context),
+        PriorityConfigurationOverride: _json,
     });
 };
 const se_StartMatchBackfillInput = (input, context) => {
@@ -3151,6 +3152,7 @@ const de_GameSessionPlacement = (output, context) => {
         PlacementId: __expectString,
         PlayerLatencies: (_) => de_PlayerLatencyList(_, context),
         Port: __expectInt32,
+        PriorityConfigurationOverride: _json,
         StartTime: (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
         Status: __expectString,
     });

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

@@ -32,9 +32,9 @@ declare const DescribeGameSessionPlacementCommand_base: {
  *          <p>To get game session placement details, specify the placement ID.</p>
  *          <p>This operation is not designed to be continually called to track game session status.
  *             This practice can cause you to exceed your API limit, which results in errors. Instead,
- *             you must configure configure an Amazon Simple Notification Service (SNS) topic to receive notifications from
- *             FlexMatch or queues. Continuously polling with <code>DescribeGameSessionPlacement</code>
- *             should only be used for games in development with low game session usage. </p>
+ *             you must configure an Amazon Simple Notification Service (SNS) topic to receive notifications from FlexMatch or
+ *             queues. Continuously polling with <code>DescribeGameSessionPlacement</code> should only
+ *             be used for games in development with low game session usage. </p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -82,6 +82,12 @@ declare const DescribeGameSessionPlacementCommand_base: {
  * //     ],
  * //     GameSessionData: "STRING_VALUE",
  * //     MatchmakerData: "STRING_VALUE",
+ * //     PriorityConfigurationOverride: { // PriorityConfigurationOverride
+ * //       PlacementFallbackStrategy: "DEFAULT_AFTER_SINGLE_PASS" || "NONE",
+ * //       LocationOrder: [ // LocationOrderOverrideList // required
+ * //         "STRING_VALUE",
+ * //       ],
+ * //     },
  * //   },
  * // };
  *

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

@@ -1,7 +1,7 @@
 import { Command as $Command } from "@smithy/smithy-client";
 import { MetadataBearer as __MetadataBearer } from "@smithy/types";
 import { GameLiftClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../GameLiftClient";
-import { ListContainerFleetsInput, ListContainerFleetsOutput } from "../models/models_0";
+import { ListContainerFleetsInput, ListContainerFleetsOutput } from "../models/models_1";
 /**
  * @public
  */

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

@@ -27,46 +27,84 @@ declare const StartGameSessionPlacementCommand_base: {
     getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
 };
 /**
- * <p>Places a request for a new game session in a queue. When processing a placement
- *             request, Amazon GameLift searches for available resources on the queue's destinations, scanning
- *             each until it finds resources or the placement request times out.</p>
- *          <p>A game session placement request can also request player sessions. When a new game
- *             session is successfully created, Amazon GameLift creates a player session for each player
- *             included in the request.</p>
- *          <p>When placing a game session, by default Amazon GameLift tries each fleet in the order they are
- *             listed in the queue configuration. Ideally, a queue's destinations are listed in
- *             preference order.</p>
- *          <p>Alternatively, when requesting a game session with players, you can also provide
- *             latency data for each player in relevant Regions. Latency data indicates the performance
- *             lag a player experiences when connected to a fleet in the Region. Amazon GameLift uses latency
- *             data to reorder the list of destinations to place the game session in a Region with
- *             minimal lag. If latency data is provided for multiple players, Amazon GameLift calculates each
- *             Region's average lag for all players and reorders to get the best game play across all
- *             players. </p>
- *          <p>To place a new game session request, specify the following:</p>
+ * <p>Makes a request to start a new game session using a game session queue. When
+ *             processing a placement request in a queue, Amazon GameLift finds the best possible available
+ *             resource to host the game session and prompts the resource to start the game session.  </p>
+ *          <p>
+ *             <b>Request options</b>
+ *          </p>
+ *          <p>Call this API with the following minimum parameters:
+ *                 <i>GameSessionQueueName</i>,
+ *                 <i>MaximumPlayerSessionCount</i>, and
+ *             <i>PlacementID</i>. You can also include game session data (data formatted
+ *             as strings) or game properties (data formatted as key-value pairs) to pass to the new
+ *             game session.</p>
  *          <ul>
  *             <li>
- *                <p>The queue name and a set of game session properties and settings</p>
+ *                <p>You can change how Amazon GameLift chooses a hosting resource for the new game session.
+ *                     Prioritizing resources for game session placements is defined when you configure
+ *                     a game session queue. You can use the default prioritization process or specify
+ *                     a custom process by providing a <a href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_PriorityConfiguration.html">
+ *                         PriorityConfiguration</a> when you create or update a queue.</p>
+ *                <ul>
+ *                   <li>
+ *                      <p>Prioritize based on resource cost and location, using the queue's
+ *                             configured priority settings. Call this API with the minimum
+ *                             parameters.</p>
+ *                   </li>
+ *                   <li>
+ *                      <p>Prioritize based on latency. Include a set of values for
+ *                                 <i>PlayerLatencies</i>. You can provide latency data
+ *                             with or without player session data. This option instructs Amazon GameLift to
+ *                             reorder the queue's prioritized locations list based on the latency
+ *                             data. If latency data is provided for multiple players, Amazon GameLift
+ *                             calculates each location's average latency for all players and reorders
+ *                             to find the lowest latency across all players. Don't include latency
+ *                             data if you're providing a custom list of locations.</p>
+ *                   </li>
+ *                   <li>
+ *                      <p>Prioritize based on a custom list of locations. If you're using a
+ *                             queue that's configured to prioritize location first (see <a href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_PriorityConfiguration.html">PriorityConfiguration</a> for game session queues), use the
+ *                                 <i>PriorityConfigurationOverride</i> parameter to
+ *                             substitute a different location list for this placement request. When
+ *                             prioritizing placements by location, Amazon GameLift searches each location in
+ *                             prioritized order to find an available hosting resource for the new game
+ *                             session. You can choose whether to use the override list for the first
+ *                             placement attempt only or for all attempts.</p>
+ *                   </li>
+ *                </ul>
  *             </li>
  *             <li>
- *                <p>A unique ID (such as a UUID) for the placement. You use this ID to track the
- *                     status of the placement request</p>
+ *                <p>You can request new player sessions for a group of players. Include the
+ *                         <i>DesiredPlayerSessions</i> parameter and include at minimum
+ *                     a unique player ID for each. You can also include player-specific data to pass
+ *                     to the new game session. </p>
  *             </li>
+ *          </ul>
+ *          <p>
+ *             <b>Result</b>
+ *          </p>
+ *          <p>If successful, this request generates a new game session placement request and adds it
+ *             to the game session queue for Amazon GameLift to process in turn. You can track the status of
+ *             individual placement requests by calling <a href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeGameSessionPlacement.html">DescribeGameSessionPlacement</a>. A new game session is running if the status
+ *             is <code>FULFILLED</code> and the request returns the game session connection
+ *             information (IP address and port). If you include player session data, Amazon GameLift creates a
+ *             player session for each player ID in the request.</p>
+ *          <p>The request results in a <code>BadRequestException</code> in the following
+ *             situations:</p>
+ *          <ul>
  *             <li>
- *                <p>(Optional) A set of player data and a unique player ID for each player that
- *                     you are joining to the new game session (player data is optional, but if you
- *                     include it, you must also provide a unique ID for each player)</p>
+ *                <p>If the request includes both <i>PlayerLatencies</i> and
+ *                         <i>PriorityConfigurationOverride</i> parameters.</p>
  *             </li>
  *             <li>
- *                <p>Latency data for all players (if you want to optimize game play for the
- *                     players)</p>
+ *                <p>If the request includes the <i>PriorityConfigurationOverride</i>
+ *                     parameter and designates a queue doesn't prioritize locations.</p>
  *             </li>
  *          </ul>
- *          <p>If successful, a new game session placement is created.</p>
- *          <p>To track the status of a placement request, call <a href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeGameSessionPlacement.html">DescribeGameSessionPlacement</a> and check the request's status. If the status
- *             is <code>FULFILLED</code>, a new game session has been created and a game session ARN
- *             and Region are referenced. If the placement request times out, you can resubmit the
- *             request or retry it with a different queue. </p>
+ *          <p>Amazon GameLift continues to retry each placement request until it reaches the queue's timeout
+ *             setting. If a request times out, you can resubmit the request to the same queue or try a
+ *             different queue. </p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript
@@ -98,6 +136,12 @@ declare const StartGameSessionPlacementCommand_base: {
  *     },
  *   ],
  *   GameSessionData: "STRING_VALUE",
+ *   PriorityConfigurationOverride: { // PriorityConfigurationOverride
+ *     PlacementFallbackStrategy: "DEFAULT_AFTER_SINGLE_PASS" || "NONE",
+ *     LocationOrder: [ // LocationOrderOverrideList // required
+ *       "STRING_VALUE",
+ *     ],
+ *   },
  * };
  * const command = new StartGameSessionPlacementCommand(input);
  * const response = await client.send(command);
@@ -137,6 +181,12 @@ declare const StartGameSessionPlacementCommand_base: {
  * //     ],
  * //     GameSessionData: "STRING_VALUE",
  * //     MatchmakerData: "STRING_VALUE",
+ * //     PriorityConfigurationOverride: { // PriorityConfigurationOverride
+ * //       PlacementFallbackStrategy: "DEFAULT_AFTER_SINGLE_PASS" || "NONE",
+ * //       LocationOrder: [ // LocationOrderOverrideList // required
+ * //         "STRING_VALUE",
+ * //       ],
+ * //     },
  * //   },
  * // };
  *
@@ -162,6 +212,9 @@ declare const StartGameSessionPlacementCommand_base: {
  * @throws {@link UnauthorizedException} (client fault)
  *  <p>The client failed authentication. Clients should not retry such requests.</p>
  *
+ * @throws {@link UnsupportedRegionException} (client fault)
+ *  <p>The requested operation is not supported in the Region specified.</p>
+ *
  * @throws {@link GameLiftServiceException}
  * <p>Base exception class for all service exceptions from GameLift service.</p>
  *

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

@@ -77,6 +77,12 @@ declare const StopGameSessionPlacementCommand_base: {
  * //     ],
  * //     GameSessionData: "STRING_VALUE",
  * //     MatchmakerData: "STRING_VALUE",
+ * //     PriorityConfigurationOverride: { // PriorityConfigurationOverride
+ * //       PlacementFallbackStrategy: "DEFAULT_AFTER_SINGLE_PASS" || "NONE",
+ * //       LocationOrder: [ // LocationOrderOverrideList // required
+ * //         "STRING_VALUE",
+ * //       ],
+ * //     },
  * //   },
  * // };
  *

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

@@ -27,46 +27,55 @@ declare const TerminateGameSessionCommand_base: {
     getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
 };
 /**
- * <p>Ends a game session that's currently in progress. You can use this action to terminate
- *             any game session that isn't in <code>TERMINATED</code> or <code>TERMINATING</code>
- *             status. Terminating a game session is the most efficient way to free up a server process
- *             when it's hosting a game session that's in a bad state or not ending naturally. You can
- *             use this action to terminate a game session that's being hosted on any type of Amazon GameLift
- *             fleet compute, including computes for managed EC2, managed container, and Anywhere
- *             fleets.</p>
- *          <p>There are two potential methods for terminating a game session:</p>
- *          <ul>
- *             <li>
- *                <p>With a graceful termination, the Amazon GameLift service prompts the server process to initiate its
- *                     normal game session shutdown sequence. This sequence is implemented in the game
- *                     server code and might involve a variety of actions to gracefully end a game
- *                     session, such as notifying players, and stop the server process. </p>
- *             </li>
- *             <li>
- *                <p>With a forceful termination, the Amazon GameLift service takes immediate action to terminate the game
- *                     session by stopping the server process. Termination occurs without the normal
- *                     game session shutdown sequence. </p>
- *             </li>
- *          </ul>
+ * <p>Ends a game session that's currently in progress. Use this action to terminate any
+ *             game session that isn't in <code>ERROR</code> status. Terminating a game session is the
+ *             most efficient way to free up a server process when it's hosting a game session that's
+ *             in a bad state or not ending properly. You can use this action to terminate a game
+ *             session that's being hosted on any type of Amazon GameLift fleet compute, including computes for
+ *             managed EC2, managed container, and Anywhere fleets. The game server must be integrated
+ *             with Amazon GameLift server SDK 5.x or greater.</p>
  *          <p>
  *             <b>Request options</b>
  *          </p>
+ *          <p>Request termination for a single game session. Provide the game session ID and the
+ *             termination mode. There are two potential methods for terminating a game session:</p>
  *          <ul>
  *             <li>
- *                <p>Request termination for a single game session. Provide the game session ID and
- *                     the termination method. </p>
+ *                <p>Initiate a graceful termination using the normal game session shutdown
+ *                     sequence. With this mode, the Amazon GameLift service prompts the server process that's
+ *                     hosting the game session by calling the server SDK callback method
+ *                         <code>OnProcessTerminate()</code>. The callback implementation is part of
+ *                     the custom game server code. It might involve a variety of actions to gracefully
+ *                     end a game session, such as notifying players, before stopping the server
+ *                     process.</p>
+ *             </li>
+ *             <li>
+ *                <p>Force an immediate game session termination. With this mode, the Amazon GameLift
+ *                     service takes action to stop the server process, which ends the game session
+ *                     without the normal game session shutdown sequence. </p>
  *             </li>
  *          </ul>
  *          <p>
  *             <b>Results</b>
  *          </p>
- *          <p>If successful, game session termination is initiated, which includes changing the game
- *             session status to <code>TERMINATING</code>. As a result of this action, and depending on
- *             the implementation of <code>OnProcessTerminate()</code>, the server process either
- *             becomes available to host a new game session, or it's recycled and a new server process
- *             started with availability to host a game session. The game session status is changed to
- *                 <code>TERMINATED</code>, with a status reason that indicates the termination method
- *             used.</p>
+ *          <p>If successful, game session termination is initiated. During this activity, the game
+ *             session status is changed to <code>TERMINATING</code>. When completed, the server
+ *             process that was hosting the game session has been stopped and replaced with a new
+ *             server process that's ready to host a new game session. The old game session's status is
+ *             changed to <code>TERMINATED</code> with a status reason that indicates the termination
+ *             method used.</p>
+ *          <p>
+ *             <b>Learn more</b>
+ *          </p>
+ *          <p>
+ *             <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html">Add Amazon GameLift to your game server</a>
+ *          </p>
+ *          <p>Amazon GameLift server SDK 5 reference guide for <code>OnProcessTerminate()</code>
+ *             (<a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/integration-server-sdk5-cpp-initsdk.html">C++</a>)
+ *             (<a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/integration-server-sdk5-csharp-initsdk.html">C#</a>)
+ *             (<a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/integration-server-sdk5-unreal-initsdk.html">Unreal</a>)
+ *             (<a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/integration-server-sdk-go-initsdk.html">Go</a>)
+ *         </p>
  * @example
  * Use a bare-bones client and the command you need to make an API call.
  * ```javascript

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

@@ -4613,9 +4613,9 @@ export interface GameSessionQueueDestination {
 }
 /**
  * <p>A list of fleet locations where a game session queue can place new game sessions. You
- *             can use a filter to temporarily turn off placements for specific locations. For queues
- *             that have multi-location fleets, you can use a filter configuration allow placement with
- *             some, but not all of these locations.</p>
+ *             can use a filter to temporarily exclude specific locations from receiving placements.
+ *             For queues that have multi-location fleets, you can use a filter configuration allow
+ *             placement with some, but not all, of a fleet's locations.</p>
  * @public
  */
 export interface FilterConfiguration {
@@ -4664,54 +4664,56 @@ export declare const PriorityType: {
  */
 export type PriorityType = (typeof PriorityType)[keyof typeof PriorityType];
 /**
- * <p>Custom prioritization settings for use by a game session queue when placing new game
- *             sessions with available game servers. When defined, this configuration replaces the
- *             default FleetIQ prioritization process, which is as follows:</p>
+ * <p>Custom prioritization settings for a game session queue to use when searching for
+ *             available game servers to place new game sessions. This configuration replaces the
+ *             default FleetIQ prioritization process. </p>
+ *          <p>By default, a queue makes placements based on the following default
+ *             prioritizations:</p>
  *          <ul>
  *             <li>
- *                <p>If player latency data is included in a game session request, destinations and
- *                     locations are prioritized first based on lowest average latency (1), then on
- *                     lowest hosting cost (2), then on destination list order (3), and finally on
- *                     location (alphabetical) (4). This approach ensures that the queue's top priority
- *                     is to place game sessions where average player latency is lowest, and--if
- *                     latency is the same--where the hosting cost is less, etc.</p>
+ *                <p>If player latency data is included in a game session request, Amazon GameLift
+ *                     prioritizes placing game sessions where the average player latency is lowest.
+ *                     Amazon GameLift re-orders the queue's destinations and locations (for multi-location
+ *                     fleets) based on the following priorities: (1) the lowest average latency across
+ *                     all players, (2) the lowest hosting cost, (3) the queue's default destination
+ *                     order, and then (4), an alphabetic list of locations.</p>
  *             </li>
  *             <li>
- *                <p>If player latency data is not included, destinations and locations are
- *                     prioritized first on destination list order (1), and then on location
- *                     (alphabetical) (2). This approach ensures that the queue's top priority is to
- *                     place game sessions on the first destination fleet listed. If that fleet has
- *                     multiple locations, the game session is placed on the first location (when
- *                     listed alphabetically).</p>
+ *                <p>If player latency data is not included, Amazon GameLift prioritizes placing game
+ *                     sessions in the queue's first destination. If that fleet has multiple locations,
+ *                     the game session is placed on the first location (when listed alphabetically).
+ *                     Amazon GameLift re-orders the queue's destinations and locations (for multi-location
+ *                     fleets) based on the following priorities: (1) the queue's default destination
+ *                     order, and then (2) an alphabetic list of locations.</p>
  *             </li>
  *          </ul>
- *          <p>Changing the priority order will affect how game sessions are placed.</p>
  * @public
  */
 export interface PriorityConfiguration {
     /**
-     * <p>The recommended sequence to use when prioritizing where to place new game sessions.
-     *             Each type can only be listed once.</p>
+     * <p>A custom sequence to use when prioritizing where to place new game sessions. Each
+     *             priority type is listed once.</p>
      *          <ul>
      *             <li>
      *                <p>
-     *                   <code>LATENCY</code> -- FleetIQ prioritizes locations where the average player
-     *                     latency (provided in each game session request) is lowest. </p>
+     *                   <code>LATENCY</code> -- Amazon GameLift prioritizes locations where the average player
+     *                     latency is lowest. Player latency data is provided in each game session
+     *                     placement request.</p>
      *             </li>
      *             <li>
      *                <p>
-     *                   <code>COST</code> -- FleetIQ prioritizes destinations with the lowest current
+     *                   <code>COST</code> -- Amazon GameLift prioritizes destinations with the lowest current
      *                     hosting costs. Cost is evaluated based on the location, instance type, and fleet
-     *                     type (Spot or On-Demand) for each destination in the queue.</p>
+     *                     type (Spot or On-Demand) of each destination in the queue.</p>
      *             </li>
      *             <li>
      *                <p>
-     *                   <code>DESTINATION</code> -- FleetIQ prioritizes based on the order that
-     *                     destinations are listed in the queue configuration.</p>
+     *                   <code>DESTINATION</code> -- Amazon GameLift prioritizes based on the list order of
+     *                     destinations in the queue configuration.</p>
      *             </li>
      *             <li>
      *                <p>
-     *                   <code>LOCATION</code> -- FleetIQ prioritizes based on the provided order of
+     *                   <code>LOCATION</code> -- Amazon GameLift prioritizes based on the provided order of
      *                     locations, as defined in <code>LocationOrder</code>. </p>
      *             </li>
      *          </ul>
@@ -4720,9 +4722,11 @@ export interface PriorityConfiguration {
     PriorityOrder?: PriorityType[] | undefined;
     /**
      * <p>The prioritization order to use for fleet locations, when the
-     *                 <code>PriorityOrder</code> property includes <code>LOCATION</code>. Locations are
-     *             identified by Amazon Web Services Region codes such as <code>us-west-2</code>. Each location can only
-     *             be listed once. </p>
+     *                 <code>PriorityOrder</code> property includes <code>LOCATION</code>. Locations can
+     *             include Amazon Web Services Region codes (such as <code>us-west-2</code>), local zones, and custom
+     *             locations (for Anywhere fleets). Each location must be listed only once. For details, see
+     *             <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-regions.html">Amazon GameLift service locations.</a>
+     *          </p>
      * @public
      */
     LocationOrder?: string[] | undefined;
@@ -7637,6 +7641,63 @@ export interface PlayerLatency {
      */
     LatencyInMilliseconds?: number | undefined;
 }
+/**
+ * @public
+ * @enum
+ */
+export declare const PlacementFallbackStrategy: {
+    readonly DEFAULT_AFTER_SINGLE_PASS: "DEFAULT_AFTER_SINGLE_PASS";
+    readonly NONE: "NONE";
+};
+/**
+ * @public
+ */
+export type PlacementFallbackStrategy = (typeof PlacementFallbackStrategy)[keyof typeof PlacementFallbackStrategy];
+/**
+ * <p>An alternate list of prioritized locations for use with a game session queue. When
+ *             this property is included in a <a href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_StartGameSessionPlacement.html">StartGameSessionPlacement</a> request, this list overrides the queue's default
+ *             location prioritization, as defined in the queue's <a href="gamelift/latest/apireference/API_PriorityConfiguration.html">PriorityConfiguration</a> setting (<i>LocationOrder</i>). This
+ *             property overrides the queue's default priority list for individual placement requests
+ *             only. Use this property only with queues that have a <code>PriorityConfiguration</code>
+ *             setting that prioritizes first. </p>
+ *          <note>
+ *             <p>A priority configuration override list does not override a queue's
+ *                 FilterConfiguration setting, if the queue has one. Filter configurations are used to
+ *                 limit placements to a subset of the locations in a queue's destinations. If the
+ *                 override list includes a location that's not included in the FilterConfiguration
+ *                 allowed list, Amazon GameLift won't attempt to place a game session there.</p>
+ *          </note>
+ * @public
+ */
+export interface PriorityConfigurationOverride {
+    /**
+     * <p>Instructions for how to use the override list if the first round of placement attempts fails. The first round is a failure if
+     *             Amazon GameLift searches all listed locations, in all of the queue's destinations, without finding an available hosting resource
+     *             for a new game session. Valid strategies include: </p>
+     *          <ul>
+     *             <li>
+     *                <p>
+     *                   <code>DEFAULT_AFTER_SINGLE_PASS</code> -- After the first round of placement attempts, discard the override list and
+     *             use the queue's default location priority list. Continue to use the queue's default list until the placement request times out.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>NONE</code> -- Continue to use the override list for all rounds of placement attempts until the placement request times out.</p>
+     *             </li>
+     *          </ul>
+     * @public
+     */
+    PlacementFallbackStrategy?: PlacementFallbackStrategy | undefined;
+    /**
+     * <p>A prioritized list of hosting locations. The list can include Amazon Web Services Regions (such as
+     *                 <code>us-west-2</code>), local zones, and custom locations (for Anywhere fleets).
+     *             Each location must be listed only once. For details, see
+     *             <a href="https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-regions.html">Amazon GameLift service locations.</a>
+     *          </p>
+     * @public
+     */
+    LocationOrder: string[] | undefined;
+}
 /**
  * @public
  * @enum
@@ -7662,7 +7723,7 @@ export type GameSessionPlacementState = (typeof GameSessionPlacementState)[keyof
  *                     <code>FULFILLED</code>. When the placement is in <code>PENDING</code> status,
  *                 Amazon GameLift may attempt to place a game session multiple times before succeeding. With
  *                 each attempt it creates a <a href="https://docs.aws.amazon.com/gamelift/latest/apireference/API_GameSession">https://docs.aws.amazon.com/gamelift/latest/apireference/API_GameSession</a> object and updates this
- *                 placement object with the new game session properties..</p>
+ *                 placement object with the new game session properties.</p>
  *          </note>
  * @public
  */
@@ -7749,7 +7810,7 @@ export interface GameSessionPlacement {
      */
     GameSessionRegion?: string | undefined;
     /**
-     * <p>A set of values, expressed in milliseconds, that indicates the amount of latency that a player experiences when connected to @aws; Regions.</p>
+     * <p>A set of values, expressed in milliseconds, that indicates the amount of latency that a player experiences when connected to Amazon Web Services Regions.</p>
      * @public
      */
     PlayerLatencies?: PlayerLatency[] | undefined;
@@ -7813,6 +7874,16 @@ export interface GameSessionPlacement {
      * @public
      */
     MatchmakerData?: string | undefined;
+    /**
+     * <p>A prioritized list of locations to use with a game session placement request and
+     *             instructions on how to use it. This list overrides a queue's prioritized location list
+     *             for a single game session placement request only. The list can include Amazon Web Services Regions,
+     *             local zones, and custom locations (for Anywhere fleets). The fallback strategy instructs
+     *             Amazon GameLift to use the override list for the first placement attempt only or for all
+     *             placement attempts.</p>
+     * @public
+     */
+    PriorityConfigurationOverride?: PriorityConfigurationOverride | undefined;
 }
 /**
  * @public
@@ -8188,7 +8259,7 @@ export interface Player {
      */
     Team?: string | undefined;
     /**
-     * <p>A set of values, expressed in milliseconds, that indicates the amount of latency that a player experiences when connected to @aws; Regions. If this property is present, FlexMatch considers placing the match only in
+     * <p>A set of values, expressed in milliseconds, that indicates the amount of latency that a player experiences when connected to Amazon Web Services Regions. If this property is present, FlexMatch considers placing the match only in
      *             Regions for which latency is reported. </p>
      *          <p>If a matchmaker has a rule that evaluates player latency, players must report latency
      *             in order to be matched. If no latency is reported in this scenario, FlexMatch assumes that
@@ -9472,45 +9543,6 @@ export interface ListComputeOutput {
      */
     NextToken?: string | undefined;
 }
-/**
- * @public
- */
-export interface ListContainerFleetsInput {
-    /**
-     * <p>The container group definition to filter the list on. Use this parameter to retrieve
-     *             only those fleets that use the specified container group definition. You can specify the
-     *             container group definition's name to get fleets with the latest versions. Alternatively,
-     *             provide an ARN value to get fleets with a specific version number.</p>
-     * @public
-     */
-    ContainerGroupDefinitionName?: string | undefined;
-    /**
-     * <p>The maximum number of results to return. Use this parameter with <code>NextToken</code> to get results as a set of sequential pages.</p>
-     * @public
-     */
-    Limit?: number | undefined;
-    /**
-     * <p>A token that indicates the start of the next sequential page of results. Use the token that is returned with a previous call to this operation. To start at the beginning of the result set, do not specify a value.</p>
-     * @public
-     */
-    NextToken?: string | undefined;
-}
-/**
- * @public
- */
-export interface ListContainerFleetsOutput {
-    /**
-     * <p>A collection of container fleet objects for all fleets that match the request
-     *             criteria.</p>
-     * @public
-     */
-    ContainerFleets?: ContainerFleet[] | undefined;
-    /**
-     * <p>A token that indicates where to resume retrieving results on the next call to this operation. If no token is returned, these results represent the end of the list.</p>
-     * @public
-     */
-    NextToken?: string | undefined;
-}
 /**
  * @internal
  */
@@ -9719,7 +9751,3 @@ export declare const GetInstanceAccessOutputFilterSensitiveLog: (obj: GetInstanc
  * @internal
  */
 export declare const ListComputeOutputFilterSensitiveLog: (obj: ListComputeOutput) => any;
-/**
- * @internal
- */
-export declare const ListContainerFleetsOutputFilterSensitiveLog: (obj: ListContainerFleetsOutput) => any;

package/dist-types/models/models_1.d.ts

@@ -1,4 +1,43 @@
-import { Alias, AnywhereConfiguration, AwsCredentials, BackfillMode, BalancingStrategy, Build, ComparisonOperatorType, Compute, ConnectionPortRange, ContainerFleet, ContainerFleetRemoveAttribute, ContainerGroupDefinition, ContainerGroupType, ContainerOperatingSystem, DeploymentConfiguration, DesiredPlayerSession, FilterConfiguration, FleetAction, FleetDeployment, FlexMatchMode, GameProperty, GameServer, GameServerContainerDefinitionInput, GameServerGroup, GameServerGroupAction, GameServerProtectionPolicy, GameServerUtilizationStatus, GameSession, GameSessionCreationLimitPolicy, GameSessionPlacement, GameSessionQueue, GameSessionQueueDestination, InstanceDefinition, IpPermission, LocationModel, LogConfiguration, MatchmakingConfiguration, MatchmakingTicket, MetricName, Player, PlayerLatency, PlayerLatencyPolicy, PlayerSessionCreationPolicy, PolicyType, PriorityConfiguration, ProtectionPolicy, ResourceCreationLimitPolicy, RoutingStrategy, RuntimeConfiguration, S3Location, ScalingAdjustmentType, Script, SupportContainerDefinitionInput, Tag, TargetConfiguration } from "./models_0";
+import { Alias, AnywhereConfiguration, AwsCredentials, BackfillMode, BalancingStrategy, Build, ComparisonOperatorType, Compute, ConnectionPortRange, ContainerFleet, ContainerFleetRemoveAttribute, ContainerGroupDefinition, ContainerGroupType, ContainerOperatingSystem, DeploymentConfiguration, DesiredPlayerSession, FilterConfiguration, FleetAction, FleetDeployment, FlexMatchMode, GameProperty, GameServer, GameServerContainerDefinitionInput, GameServerGroup, GameServerGroupAction, GameServerProtectionPolicy, GameServerUtilizationStatus, GameSession, GameSessionCreationLimitPolicy, GameSessionPlacement, GameSessionQueue, GameSessionQueueDestination, InstanceDefinition, IpPermission, LocationModel, LogConfiguration, MatchmakingConfiguration, MatchmakingTicket, MetricName, Player, PlayerLatency, PlayerLatencyPolicy, PlayerSessionCreationPolicy, PolicyType, PriorityConfiguration, PriorityConfigurationOverride, ProtectionPolicy, ResourceCreationLimitPolicy, RoutingStrategy, RuntimeConfiguration, S3Location, ScalingAdjustmentType, Script, SupportContainerDefinitionInput, Tag, TargetConfiguration } from "./models_0";
+/**
+ * @public
+ */
+export interface ListContainerFleetsInput {
+    /**
+     * <p>The container group definition to filter the list on. Use this parameter to retrieve
+     *             only those fleets that use the specified container group definition. You can specify the
+     *             container group definition's name to get fleets with the latest versions. Alternatively,
+     *             provide an ARN value to get fleets with a specific version number.</p>
+     * @public
+     */
+    ContainerGroupDefinitionName?: string | undefined;
+    /**
+     * <p>The maximum number of results to return. Use this parameter with <code>NextToken</code> to get results as a set of sequential pages.</p>
+     * @public
+     */
+    Limit?: number | undefined;
+    /**
+     * <p>A token that indicates the start of the next sequential page of results. Use the token that is returned with a previous call to this operation. To start at the beginning of the result set, do not specify a value.</p>
+     * @public
+     */
+    NextToken?: string | undefined;
+}
+/**
+ * @public
+ */
+export interface ListContainerFleetsOutput {
+    /**
+     * <p>A collection of container fleet objects for all fleets that match the request
+     *             criteria.</p>
+     * @public
+     */
+    ContainerFleets?: ContainerFleet[] | undefined;
+    /**
+     * <p>A token that indicates where to resume retrieving results on the next call to this operation. If no token is returned, these results represent the end of the list.</p>
+     * @public
+     */
+    NextToken?: string | undefined;
+}
 /**
  * @public
  */
@@ -884,7 +923,7 @@ export interface StartGameSessionPlacementInput {
      */
     GameSessionName?: string | undefined;
     /**
-     * <p>A set of values, expressed in milliseconds, that indicates the amount of latency that a player experiences when connected to @aws; Regions. This information is used to try to place the new game session where it
+     * <p>A set of values, expressed in milliseconds, that indicates the amount of latency that a player experiences when connected to Amazon Web Services Regions. This information is used to try to place the new game session where it
      *             can offer the best possible gameplay experience for the players. </p>
      * @public
      */
@@ -899,6 +938,16 @@ export interface StartGameSessionPlacementInput {
      * @public
      */
     GameSessionData?: string | undefined;
+    /**
+     * <p>A prioritized list of locations to use for the game session placement and instructions
+     *             on how to use it. This list overrides a queue's prioritized location list for this game
+     *             session placement request only. You can include Amazon Web Services Regions, local zones, and custom
+     *             locations (for Anywhere fleets). Choose a fallback strategy to instruct Amazon GameLift to use
+     *             the override list for the first placement attempt only or for all placement
+     *             attempts.</p>
+     * @public
+     */
+    PriorityConfigurationOverride?: PriorityConfigurationOverride | undefined;
 }
 /**
  * @public
@@ -1168,19 +1217,21 @@ export interface TerminateGameSessionInput {
      *          <ul>
      *             <li>
      *                <p>
-     *                   <code>TRIGGER_ON_PROCESS_TERMINATE</code> – Sends an
-     *                         <code>OnProcessTerminate()</code> callback to the server process to initiate
-     *                     the normal game session shutdown sequence. At a minimum, the callback method
-     *                     must include a call to the server SDK action <code>ProcessEnding()</code>, which
-     *                     is how the server process signals that a game session is ending. If the server
-     *                     process doesn't call <code>ProcessEnding()</code>, this termination method won't
-     *                     be successful.</p>
+     *                   <code>TRIGGER_ON_PROCESS_TERMINATE</code> – Prompts the Amazon GameLift service to
+     *                     send an <code>OnProcessTerminate()</code> callback to the server process and
+     *                     initiate the normal game session shutdown sequence. The
+     *                         <code>OnProcessTerminate</code> method, which is implemented in the game
+     *                     server code, must include a call to the server SDK action
+     *                         <code>ProcessEnding()</code>, which is how the server process signals to
+     *                     Amazon GameLift that a game session is ending. If the server process doesn't call
+     *                         <code>ProcessEnding()</code>, the game session termination won't conclude
+     *                     successfully.</p>
      *             </li>
      *             <li>
      *                <p>
-     *                   <code>FORCE_TERMINATE</code> – Takes action to stop the server process, using
-     *                     existing methods to control how server processes run on an Amazon GameLift managed
-     *                     compute. </p>
+     *                   <code>FORCE_TERMINATE</code> – Prompts the Amazon GameLift service to stop the server
+     *                     process immediately. Amazon GameLift takes action (depending on the type of fleet) to
+     *                     shut down the server process without the normal game session shutdown sequence. </p>
      *                <note>
      *                   <p>This method is not available for game sessions that are running on
      *                         Anywhere fleets unless the fleet is deployed with the Amazon GameLift Agent. In this
@@ -2156,6 +2207,10 @@ export interface ValidateMatchmakingRuleSetOutput {
      */
     Valid?: boolean | undefined;
 }
+/**
+ * @internal
+ */
+export declare const ListContainerFleetsOutputFilterSensitiveLog: (obj: ListContainerFleetsOutput) => any;
 /**
  * @internal
  */

package/dist-types/ts3.4/commands/ListContainerFleetsCommand.d.ts

@@ -8,7 +8,7 @@ import {
 import {
   ListContainerFleetsInput,
   ListContainerFleetsOutput,
-} from "../models/models_0";
+} from "../models/models_1";
 export { __MetadataBearer };
 export { $Command };
 export interface ListContainerFleetsCommandInput

package/dist-types/ts3.4/models/models_0.d.ts

@@ -1736,6 +1736,16 @@ export interface PlayerLatency {
   RegionIdentifier?: string | undefined;
   LatencyInMilliseconds?: number | undefined;
 }
+export declare const PlacementFallbackStrategy: {
+  readonly DEFAULT_AFTER_SINGLE_PASS: "DEFAULT_AFTER_SINGLE_PASS";
+  readonly NONE: "NONE";
+};
+export type PlacementFallbackStrategy =
+  (typeof PlacementFallbackStrategy)[keyof typeof PlacementFallbackStrategy];
+export interface PriorityConfigurationOverride {
+  PlacementFallbackStrategy?: PlacementFallbackStrategy | undefined;
+  LocationOrder: string[] | undefined;
+}
 export declare const GameSessionPlacementState: {
   readonly CANCELLED: "CANCELLED";
   readonly FAILED: "FAILED";
@@ -1764,6 +1774,7 @@ export interface GameSessionPlacement {
   PlacedPlayerSessions?: PlacedPlayerSession[] | undefined;
   GameSessionData?: string | undefined;
   MatchmakerData?: string | undefined;
+  PriorityConfigurationOverride?: PriorityConfigurationOverride | undefined;
 }
 export interface DescribeGameSessionPlacementOutput {
   GameSessionPlacement?: GameSessionPlacement | undefined;
@@ -2092,15 +2103,6 @@ export interface ListComputeOutput {
   ComputeList?: Compute[] | undefined;
   NextToken?: string | undefined;
 }
-export interface ListContainerFleetsInput {
-  ContainerGroupDefinitionName?: string | undefined;
-  Limit?: number | undefined;
-  NextToken?: string | undefined;
-}
-export interface ListContainerFleetsOutput {
-  ContainerFleets?: ContainerFleet[] | undefined;
-  NextToken?: string | undefined;
-}
 export declare const AcceptMatchInputFilterSensitiveLog: (
   obj: AcceptMatchInput
 ) => any;
@@ -2247,6 +2249,3 @@ export declare const GetInstanceAccessOutputFilterSensitiveLog: (
 export declare const ListComputeOutputFilterSensitiveLog: (
   obj: ListComputeOutput
 ) => any;
-export declare const ListContainerFleetsOutputFilterSensitiveLog: (
-  obj: ListContainerFleetsOutput
-) => any;

package/dist-types/ts3.4/models/models_1.d.ts

@@ -44,6 +44,7 @@ import {
   PlayerSessionCreationPolicy,
   PolicyType,
   PriorityConfiguration,
+  PriorityConfigurationOverride,
   ProtectionPolicy,
   ResourceCreationLimitPolicy,
   RoutingStrategy,
@@ -55,6 +56,15 @@ import {
   Tag,
   TargetConfiguration,
 } from "./models_0";
+export interface ListContainerFleetsInput {
+  ContainerGroupDefinitionName?: string | undefined;
+  Limit?: number | undefined;
+  NextToken?: string | undefined;
+}
+export interface ListContainerFleetsOutput {
+  ContainerFleets?: ContainerFleet[] | undefined;
+  NextToken?: string | undefined;
+}
 export interface ListContainerGroupDefinitionsInput {
   ContainerGroupType?: ContainerGroupType | undefined;
   Limit?: number | undefined;
@@ -232,6 +242,7 @@ export interface StartGameSessionPlacementInput {
   PlayerLatencies?: PlayerLatency[] | undefined;
   DesiredPlayerSessions?: DesiredPlayerSession[] | undefined;
   GameSessionData?: string | undefined;
+  PriorityConfigurationOverride?: PriorityConfigurationOverride | undefined;
 }
 export interface StartGameSessionPlacementOutput {
   GameSessionPlacement?: GameSessionPlacement | undefined;
@@ -478,6 +489,9 @@ export interface ValidateMatchmakingRuleSetInput {
 export interface ValidateMatchmakingRuleSetOutput {
   Valid?: boolean | undefined;
 }
+export declare const ListContainerFleetsOutputFilterSensitiveLog: (
+  obj: ListContainerFleetsOutput
+) => any;
 export declare const ListContainerGroupDefinitionsOutputFilterSensitiveLog: (
   obj: ListContainerGroupDefinitionsOutput
 ) => any;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@aws-sdk/client-gamelift",
   "description": "AWS SDK for JavaScript Gamelift Client for Node.js, Browser and React Native",
-  "version": "3.726.1",
+  "version": "3.728.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
     "build:cjs": "node ../../scripts/compilation/inline client-gamelift",