gamelift

type AcceptMatchInput struct {
	// A unique identifier for a matchmaking ticket. The ticket must be in status
	// REQUIRES_ACCEPTANCE; otherwise this request will fail.
	TicketId *string
	// A unique identifier for a player delivering the response. This parameter can
	// include one or multiple player IDs.
	PlayerIds []*string
	// Player response to the proposed match.
	AcceptanceType types.AcceptanceType
}

type AcceptMatchOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ClaimGameServerInput struct {
	// An identifier for the game server group. When claiming a specific game server,
	// this is the game server group whether the game server is located. When
	// requesting that GameLift FleetIQ locate an available game server, this is the
	// game server group to search on. You can use either the GameServerGroup () name
	// or ARN value.
	GameServerGroupName *string
	// A set of custom game server properties, formatted as a single string value, to
	// be passed to the claimed game server.
	GameServerData *string
	// A custom string that uniquely identifies the game server to claim. If this
	// parameter is left empty, GameLift FleetIQ searches for an available game server
	// in the specified game server group.
	GameServerId *string
}

type ClaimGameServerOutput struct {
	// Object that describes the newly claimed game server resource.
	GameServer *types.GameServer

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Client struct {
	// contains filtered or unexported fields
}

type CreateAliasInput struct {
	// A descriptive label that is associated with an alias. Alias names do not need to
	// be unique.
	Name *string
	// A list of labels to assign to the new alias resource. Tags are developer-defined
	// key-value pairs. Tagging AWS resources are useful for resource management,
	// access management and cost allocation. For more information, see  Tagging AWS
	// Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in
	// the AWS General Reference. Once the resource is created, you can use TagResource
	// (), UntagResource (), and ListTagsForResource () to add, remove, and view tags.
	// The maximum tag limit may be lower than stated. See the AWS General Reference
	// for actual tagging limits.
	Tags []*types.Tag
	// A human-readable description of the alias.
	Description *string
	// The routing configuration, including routing type and fleet target, for the
	// alias.
	RoutingStrategy *types.RoutingStrategy
}

type CreateAliasOutput struct {
	// The newly created alias resource.
	Alias *types.Alias

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateBuildInput struct {
	// Information indicating where your game build files are stored. Use this
	// parameter only when creating a build with files stored in an S3 bucket that you
	// own. The storage location must specify an S3 bucket name and key. The location
	// must also specify a role ARN that you set up to allow Amazon GameLift to access
	// your S3 bucket. The S3 bucket and your new build must be in the same Region.
	StorageLocation *types.S3Location
	// A descriptive label that is associated with a build. Build names do not need to
	// be unique. You can use UpdateBuild () to change this value later.
	Name *string
	// The operating system that the game server binaries are built to run on. This
	// value determines the type of fleet resources that you can use for this build. If
	// your game build contains multiple executables, they all must run on the same
	// operating system. If an operating system is not specified when creating a build,
	// Amazon GameLift uses the default value (WINDOWS_2012). This value cannot be
	// changed later.
	OperatingSystem types.OperatingSystem
	// A list of labels to assign to the new build resource. Tags are developer-defined
	// key-value pairs. Tagging AWS resources are useful for resource management,
	// access management and cost allocation. For more information, see  Tagging AWS
	// Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in
	// the AWS General Reference. Once the resource is created, you can use TagResource
	// (), UntagResource (), and ListTagsForResource () to add, remove, and view tags.
	// The maximum tag limit may be lower than stated. See the AWS General Reference
	// for actual tagging limits.
	Tags []*types.Tag
	// Version information that is associated with a build or script. Version strings
	// do not need to be unique. You can use UpdateBuild () to change this value later.
	Version *string
}

type CreateBuildOutput struct {
	// Amazon S3 location for your game build file, including bucket name and key.
	StorageLocation *types.S3Location
	// The newly created build resource, including a unique build IDs and status.
	Build *types.Build
	// This element is returned only when the operation is called without a storage
	// location. It contains credentials to use when you are uploading a build file to
	// an S3 bucket that is owned by Amazon GameLift. Credentials have a limited life
	// span. To refresh these credentials, call RequestUploadCredentials ().
	UploadCredentials *types.AwsCredentials

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateFleetInput struct {
	// A unique identifier for the AWS account with the VPC that you want to peer your
	// Amazon GameLift fleet with. You can find your account ID in the AWS Management
	// Console under account settings.
	PeerVpcAwsAccountId *string
	// Instructions for launching server processes on each instance in the fleet.
	// Server processes run either a custom game build executable or a Realtime script.
	// The runtime configuration defines the server executables or launch script file,
	// launch parameters, and the number of processes to run concurrently on each
	// instance. When creating a fleet, the runtime configuration must have at least
	// one server process configuration; otherwise the request fails with an invalid
	// request exception. (This parameter replaces the parameters ServerLaunchPath and
	// ServerLaunchParameters, although requests that contain values for these
	// parameters instead of a runtime configuration will continue to work.) This
	// parameter is required unless the parameters ServerLaunchPath and
	// ServerLaunchParameters are defined. Runtime configuration replaced these
	// parameters, but fleets that use them will continue to work.
	RuntimeConfiguration *types.RuntimeConfiguration
	// A unique identifier for an AWS IAM role that manages access to your AWS
	// services. With an instance role ARN set, any application that runs on an
	// instance in this fleet can assume the role, including install scripts, server
	// processes, and daemons (background processes). Create a role or look up a role's
	// ARN from the IAM dashboard (https://console.aws.amazon.com/iam/) in the AWS
	// Management Console. Learn more about using on-box credentials for your game
	// servers at  Access external resources from a game server
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-resources.html).
	InstanceRoleArn *string
	// A list of labels to assign to the new fleet resource. Tags are developer-defined
	// key-value pairs. Tagging AWS resources are useful for resource management,
	// access management and cost allocation. For more information, see  Tagging AWS
	// Resources (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in
	// the AWS General Reference. Once the resource is created, you can use TagResource
	// (), UntagResource (), and ListTagsForResource () to add, remove, and view tags.
	// The maximum tag limit may be lower than stated. See the AWS General Reference
	// for actual tagging limits.
	Tags []*types.Tag
	// The name of an Amazon CloudWatch metric group to add this fleet to. A metric
	// group aggregates the metrics for all fleets in the group. Specify an existing
	// metric group name, or provide a new name to create a new metric group. A fleet
	// can only be included in one metric group at a time.
	MetricGroups []*string
	// A policy that limits the number of game sessions an individual player can create
	// over a span of time for this fleet.
	ResourceCreationLimitPolicy *types.ResourceCreationLimitPolicy
	// A unique identifier for a build to be deployed on the new fleet. You can use
	// either the build ID or ARN value. The custom game server build must have been
	// successfully uploaded to Amazon GameLift and be in a READY status. This fleet
	// setting cannot be changed once the fleet is created.
	BuildId *string
	// A game session protection policy to apply to all instances in this fleet. If
	// this parameter is not set, instances in this fleet default to no protection. You
	// can change a fleet's protection policy using UpdateFleetAttributes (), but this
	// change will only affect sessions created after the policy change. You can also
	// set protection for individual instances using UpdateGameSession ().
	//
	//     *
	// NoProtection - The game session can be terminated during a scale-down event.
	//
	//
	// * FullProtection - If the game session is in an ACTIVE status, it cannot be
	// terminated during a scale-down event.
	NewGameSessionProtectionPolicy types.ProtectionPolicy
	// A unique identifier for a Realtime script to be deployed on the new fleet. You
	// can use either the script ID or ARN value. The Realtime script must have been
	// successfully uploaded to Amazon GameLift. This fleet setting cannot be changed
	// once the fleet is created.
	ScriptId *string
	// Range of IP addresses and port settings that permit inbound traffic to access
	// game sessions that are running on the fleet. For fleets using a custom game
	// build, this parameter is required before game sessions running on the fleet can
	// accept connections. For Realtime Servers fleets, Amazon GameLift automatically
	// sets TCP and UDP ranges for use by the Realtime servers. You can specify
	// multiple permission settings or add more by updating the fleet.
	EC2InboundPermissions []*types.IpPermission
	// The name of an EC2 instance type that is supported in Amazon GameLift. A fleet
	// instance type determines the computing resources of each instance in the fleet,
	// including CPU, memory, storage, and networking capacity. Amazon GameLift
	// supports the following EC2 instance types. See Amazon EC2 Instance Types
	// (http://aws.amazon.com/ec2/instance-types/) for detailed descriptions.
	EC2InstanceType types.EC2InstanceType
	// A human-readable description of a fleet.
	Description *string
	// This parameter is no longer used. Instead, specify server launch parameters in
	// the RuntimeConfiguration parameter. (Requests that specify a server launch path
	// and launch parameters instead of a runtime configuration will continue to work.)
	ServerLaunchParameters *string
	// Indicates whether to use On-Demand instances or Spot instances for this fleet.
	// If empty, the default is ON_DEMAND. Both categories of instances use identical
	// hardware and configurations based on the instance type selected for this fleet.
	// Learn more about  On-Demand versus Spot Instances
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-ec2-instances.html#gamelift-ec2-instances-spot).
	FleetType types.FleetType
	// Indicates whether to generate a TLS/SSL certificate for the new fleet. TLS
	// certificates are used for encrypting traffic between game clients and game
	// servers running on GameLift. If this parameter is not specified, the default
	// value, DISABLED, is used. This fleet setting cannot be changed once the fleet is
	// created. Learn more at Securing Client/Server Communication
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-howitworks.html#gamelift-howitworks-security).
	// Note: This feature requires the AWS Certificate Manager (ACM) service, which is
	// available in the AWS global partition but not in all other partitions. When
	// working in a partition that does not support this feature, a request for a new
	// fleet with certificate generation results fails with a 4xx unsupported Region
	// error. Valid values include:
	//
	//     * GENERATED - Generate a TLS/SSL certificate
	// for this fleet.
	//
	//     * DISABLED - (default) Do not generate a TLS/SSL
	// certificate for this fleet.
	CertificateConfiguration *types.CertificateConfiguration
	// This parameter is no longer used. Instead, specify a server launch path using
	// the RuntimeConfiguration parameter. Requests that specify a server launch path
	// and launch parameters instead of a runtime configuration will continue to work.
	ServerLaunchPath *string
	// A descriptive label that is associated with a fleet. Fleet names do not need to
	// be unique.
	Name *string
	// This parameter is no longer used. Instead, to specify where Amazon GameLift
	// should store log files once a server process shuts down, use the Amazon GameLift
	// server API ProcessReady() and specify one or more directory paths in
	// logParameters. See more information in the Server API Reference
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api-ref.html#gamelift-sdk-server-api-ref-dataypes-process).
	LogPaths []*string
	// A unique identifier for a VPC with resources to be accessed by your Amazon
	// GameLift fleet. The VPC must be in the same Region as your fleet. To look up a
	// VPC ID, use the VPC Dashboard (https://console.aws.amazon.com/vpc/) in the AWS
	// Management Console. Learn more about VPC peering in VPC Peering with Amazon
	// GameLift Fleets
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html).
	PeerVpcId *string
}

type CreateFleetOutput struct {
	// Properties for the newly created fleet.
	FleetAttributes *types.FleetAttributes

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateGameServerGroupInput struct {
	// The maximum number of instances allowed in the EC2 Auto Scaling group. During
	// autoscaling events, GameLift FleetIQ and EC2 do not scale up the group above
	// this maximum.
	MaxSize *int32
	// A list of virtual private cloud (VPC) subnets to use with instances in the game
	// server group. By default, all GameLift FleetIQ-supported availability zones are
	// used; this parameter allows you to specify VPCs that you've set up.
	VpcSubnets []*string
	// A set of EC2 instance types to use when creating instances in the group. The
	// instance definitions must specify at least two different instance types that are
	// supported by GameLift FleetIQ. For more information on instance types, see EC2
	// Instance Types
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) in the
	// Amazon EC2 User Guide.
	InstanceDefinitions []*types.InstanceDefinition
	// A list of labels to assign to the new game server group resource. Tags are
	// developer-defined key-value pairs. Tagging AWS resources are useful for resource
	// management, access management, and cost allocation. For more information, see
	// Tagging AWS Resources
	// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the AWS
	// General Reference. Once the resource is created, you can use TagResource (),
	// UntagResource (), and ListTagsForResource () to add, remove, and view tags. The
	// maximum tag limit may be lower than stated. See the AWS General Reference for
	// actual tagging limits.
	Tags []*types.Tag
	// The Amazon Resource Name (ARN
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)) for an IAM
	// role that allows Amazon GameLift to access your EC2 Auto Scaling groups. The
	// submitted role is validated to ensure that it contains the necessary permissions
	// for game server groups.
	RoleArn *string
	// The fallback balancing method to use for the game server group when Spot
	// instances in a Region become unavailable or are not viable for game hosting.
	// Once triggered, this method remains active until Spot instances can once again
	// be used. Method options include:
	//
	//     * SPOT_ONLY -- If Spot instances are
	// unavailable, the game server group provides no hosting capacity. No new
	// instances are started, and the existing nonviable Spot instances are terminated
	// (once current gameplay ends) and not replaced.
	//
	//     * SPOT_PREFERRED -- If Spot
	// instances are unavailable, the game server group continues to provide hosting
	// capacity by using On-Demand instances. Existing nonviable Spot instances are
	// terminated (once current gameplay ends) and replaced with new On-Demand
	// instances.
	BalancingStrategy types.BalancingStrategy
	// An identifier for the new game server group. This value is used to generate
	// unique ARN identifiers for the EC2 Auto Scaling group and the GameLift FleetIQ
	// game server group. The name must be unique per Region per AWS account.
	GameServerGroupName *string
	// The minimum number of instances allowed in the EC2 Auto Scaling group. During
	// autoscaling events, GameLift FleetIQ and EC2 do not scale down the group below
	// this minimum. In production, this value should be set to at least 1.
	MinSize *int32
	// Configuration settings to define a scaling policy for the Auto Scaling group
	// that is optimized for game hosting. The scaling policy uses the metric
	// "PercentUtilizedGameServers" to maintain a buffer of idle game servers that can
	// immediately accommodate new games and players. Once the game server and Auto
	// Scaling groups are created, you can update the scaling policy settings directly
	// in Auto Scaling Groups.
	AutoScalingPolicy *types.GameServerGroupAutoScalingPolicy
	// The EC2 launch template that contains configuration settings and game server
	// code to be deployed to all instances in the game server group. You can specify
	// the template using either the template name or ID. For help with creating a
	// launch template, see Creating a Launch Template for an Auto Scaling Group
	// (https://docs.aws.amazon.com/autoscaling/ec2/userguide/create-launch-template.html)
	// in the Amazon EC2 Auto Scaling User Guide.
	LaunchTemplate *types.LaunchTemplateSpecification
	// A flag that indicates whether instances in the game server group are protected
	// from early termination. Unprotected instances that have active game servers
	// running may by terminated during a scale-down event, causing players to be
	// dropped from the game. Protected instances cannot be terminated while there are
	// active game servers running. An exception to this is Spot Instances, which may
	// be terminated by AWS regardless of protection status. This property is set to
	// NO_PROTECTION by default.
	GameServerProtectionPolicy types.GameServerProtectionPolicy
}

type CreateGameServerGroupOutput struct {
	// The newly created game server group object, including the new ARN value for the
	// GameLift FleetIQ game server group and the object's status. The EC2 Auto Scaling
	// group ARN is initially null, since the group has not yet been created. This
	// value is added once the game server group status reaches ACTIVE.
	GameServerGroup *types.GameServerGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateGameSessionInput struct {
	// The maximum number of players that can be connected simultaneously to the game
	// session.
	MaximumPlayerSessionCount *int32
	// A unique identifier for an alias associated with the fleet to create a game
	// session in. You can use either the alias ID or ARN value. Each request must
	// reference either a fleet ID or alias ID, but not both.
	AliasId *string
	// A unique identifier for a player or entity creating the game session. This ID is
	// used to enforce a resource protection policy (if one exists) that limits the
	// number of concurrent active game sessions one player can have.
	CreatorId *string
	// A descriptive label that is associated with a game session. Session names do not
	// need to be unique.
	Name *string
	// Set of custom properties for a game session, formatted as key:value pairs. These
	// properties are passed to a game server process in the GameSession () object with
	// a request to start a new game session (see Start a Game Session
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)).
	GameProperties []*types.GameProperty
	// Set of custom game session properties, formatted as a single string value. This
	// data is passed to a game server process in the GameSession () object with a
	// request to start a new game session (see Start a Game Session
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)).
	GameSessionData *string
	// This parameter is no longer preferred. Please use IdempotencyToken instead.
	// Custom string that uniquely identifies a request for a new game session. Maximum
	// token length is 48 characters. If provided, this string is included in the new
	// game session's ID. (A game session ARN has the following format:
	// arn:aws:gamelift:::gamesession//.)
	GameSessionId *string
	// A unique identifier for a fleet to create a game session in. You can use either
	// the fleet ID or ARN value. Each request must reference either a fleet ID or
	// alias ID, but not both.
	FleetId *string
	// Custom string that uniquely identifies a request for a new game session. Maximum
	// token length is 48 characters. If provided, this string is included in the new
	// game session's ID. (A game session ARN has the following format:
	// arn:aws:gamelift:::gamesession//.) Idempotency tokens remain in use for 30 days
	// after a game session has ended; game session objects are retained for this time
	// period and then deleted.
	IdempotencyToken *string
}

type CreateGameSessionOutput struct {
	// Object that describes the newly created game session record.
	GameSession *types.GameSession

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateGameSessionQueueInput struct {
	// A list of labels to assign to the new game session queue resource. Tags are
	// developer-defined key-value pairs. Tagging AWS resources are useful for resource
	// management, access management and cost allocation. For more information, see
	// Tagging AWS Resources
	// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the AWS
	// General Reference. Once the resource is created, you can use TagResource (),
	// UntagResource (), and ListTagsForResource () to add, remove, and view tags. The
	// maximum tag limit may be lower than stated. See the AWS General Reference for
	// actual tagging limits.
	Tags []*types.Tag
	// A descriptive label that is associated with game session queue. Queue names must
	// be unique within each Region.
	Name *string
	// A list of fleets that can be used to fulfill game session placement requests in
	// the queue. Fleets are identified by either a fleet ARN or a fleet alias ARN.
	// Destinations are listed in default preference order.
	Destinations []*types.GameSessionQueueDestination
	// The maximum time, in seconds, that a new game session placement request remains
	// in the queue. When a request exceeds this time, the game session placement
	// changes to a TIMED_OUT status.
	TimeoutInSeconds *int32
	// A collection of latency policies to apply when processing game sessions
	// placement requests with player latency information. Multiple policies are
	// evaluated in order of the maximum latency value, starting with the lowest
	// latency values. With just one policy, the policy is enforced at the start of the
	// game session placement for the duration period. With multiple policies, each
	// policy is enforced consecutively for its duration period. For example, a queue
	// might enforce a 60-second policy followed by a 120-second policy, and then no
	// policy for the remainder of the placement. A player latency policy must set a
	// value for MaximumIndividualPlayerLatencyMilliseconds. If none is set, this API
	// request fails.
	PlayerLatencyPolicies []*types.PlayerLatencyPolicy
}

type CreateGameSessionQueueOutput struct {
	// An object that describes the newly created game session queue.
	GameSessionQueue *types.GameSessionQueue

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateMatchmakingConfigurationInput struct {
	// A human-readable description of the matchmaking configuration.
	Description *string
	// A set of custom properties for a game session, formatted as key-value pairs.
	// These properties are passed to a game server process in the GameSession ()
	// object with a request to start a new game session (see Start a Game Session
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)).
	// This information is added to the new GameSession () object that is created for a
	// successful match.
	GameProperties []*types.GameProperty
	// An SNS topic ARN that is set up to receive matchmaking notifications.
	NotificationTarget *string
	// A unique identifier for a matchmaking configuration. This name is used to
	// identify the configuration associated with a matchmaking request or ticket.
	Name *string
	// Information to be added to all events related to this matchmaking configuration.
	CustomEventData *string
	// The maximum duration, in seconds, that a matchmaking ticket can remain in
	// process before timing out. Requests that fail due to timing out can be
	// resubmitted as needed.
	RequestTimeoutSeconds *int32
	// The method used to backfill game sessions that are created with this matchmaking
	// configuration. Specify MANUAL when your game manages backfill requests manually
	// or does not use the match backfill feature. Specify AUTOMATIC to have GameLift
	// create a StartMatchBackfill () request whenever a game session has one or more
	// open slots. Learn more about manual and automatic backfill in  Backfill Existing
	// Games with FlexMatch
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/match-backfill.html).
	BackfillMode types.BackfillMode
	// The length of time (in seconds) to wait for players to accept a proposed match.
	// If any player rejects the match or fails to accept before the timeout, the
	// ticket continues to look for an acceptable match.
	AcceptanceTimeoutSeconds *int32
	// A unique identifier for a matchmaking rule set to use with this configuration.
	// You can use either the rule set name or ARN value. A matchmaking configuration
	// can only use rule sets that are defined in the same Region.
	RuleSetName *string
	// A flag that determines whether a match that was created with this configuration
	// must be accepted by the matched players. To require acceptance, set to TRUE.
	AcceptanceRequired *bool
	// A set of custom game session properties, formatted as a single string value.
	// This data is passed to a game server process in the GameSession () object with a
	// request to start a new game session (see Start a Game Session
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)).
	// This information is added to the new GameSession () object that is created for a
	// successful match.
	GameSessionData *string
	// The number of player slots in a match to keep open for future players. For
	// example, assume that the configuration's rule set specifies a match for a single
	// 12-person team. If the additional player count is set to 2, only 10 players are
	// initially selected for the match.
	AdditionalPlayerCount *int32
	// A list of labels to assign to the new matchmaking configuration resource. Tags
	// are developer-defined key-value pairs. Tagging AWS resources are useful for
	// resource management, access management and cost allocation. For more
	// information, see  Tagging AWS Resources
	// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the AWS
	// General Reference. Once the resource is created, you can use TagResource (),
	// UntagResource (), and ListTagsForResource () to add, remove, and view tags. The
	// maximum tag limit may be lower than stated. See the AWS General Reference for
	// actual tagging limits.
	Tags []*types.Tag
	// Amazon Resource Name (ARN
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html))
	// that is assigned to a GameLift game session queue resource and uniquely
	// identifies it. ARNs are unique across all Regions. These queues are used when
	// placing game sessions for matches that are created with this matchmaking
	// configuration. Queues can be located in any Region.
	GameSessionQueueArns []*string
}

type CreateMatchmakingConfigurationOutput struct {
	// Object that describes the newly created matchmaking configuration.
	Configuration *types.MatchmakingConfiguration

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateMatchmakingRuleSetInput struct {
	// A list of labels to assign to the new matchmaking rule set resource. Tags are
	// developer-defined key-value pairs. Tagging AWS resources are useful for resource
	// management, access management and cost allocation. For more information, see
	// Tagging AWS Resources
	// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the AWS
	// General Reference. Once the resource is created, you can use TagResource (),
	// UntagResource (), and ListTagsForResource () to add, remove, and view tags. The
	// maximum tag limit may be lower than stated. See the AWS General Reference for
	// actual tagging limits.
	Tags []*types.Tag
	// A collection of matchmaking rules, formatted as a JSON string. Comments are not
	// allowed in JSON, but most elements support a description field.
	RuleSetBody *string
	// A unique identifier for a matchmaking rule set. A matchmaking configuration
	// identifies the rule set it uses by this name value. Note that the rule set name
	// is different from the optional name field in the rule set body.
	Name *string
}

type CreateMatchmakingRuleSetOutput struct {
	// The newly created matchmaking rule set.
	RuleSet *types.MatchmakingRuleSet

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreatePlayerSessionInput struct {
	// Developer-defined information related to a player. Amazon GameLift does not use
	// this data, so it can be formatted as needed for use in the game.
	PlayerData *string
	// A unique identifier for the game session to add a player to.
	GameSessionId *string
	// A unique identifier for a player. Player IDs are developer-defined.
	PlayerId *string
}

type CreatePlayerSessionOutput struct {
	// Object that describes the newly created player session record.
	PlayerSession *types.PlayerSession

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreatePlayerSessionsInput struct {
	// A unique identifier for the game session to add players to.
	GameSessionId *string
	// List of unique identifiers for the players to be added.
	PlayerIds []*string
	// Map of string pairs, each specifying a player ID and a set of developer-defined
	// information related to the player. Amazon GameLift does not use this data, so it
	// can be formatted as needed for use in the game. Player data strings for player
	// IDs not included in the PlayerIds parameter are ignored.
	PlayerDataMap map[string]*string
}

type CreatePlayerSessionsOutput struct {
	// A collection of player session objects created for the added players.
	PlayerSessions []*types.PlayerSession

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateScriptInput struct {
	// The version that is associated with a build or script. Version strings do not
	// need to be unique. You can use UpdateScript () to change this value later.
	Version *string
	// A descriptive label that is associated with a script. Script names do not need
	// to be unique. You can use UpdateScript () to change this value later.
	Name *string
	// A list of labels to assign to the new script resource. Tags are
	// developer-defined key-value pairs. Tagging AWS resources are useful for resource
	// management, access management and cost allocation. For more information, see
	// Tagging AWS Resources
	// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the AWS
	// General Reference. Once the resource is created, you can use TagResource (),
	// UntagResource (), and ListTagsForResource () to add, remove, and view tags. The
	// maximum tag limit may be lower than stated. See the AWS General Reference for
	// actual tagging limits.
	Tags []*types.Tag
	// A data object containing your Realtime scripts and dependencies as a zip file.
	// The zip file can have one or multiple files. Maximum size of a zip file is 5 MB.
	// When using the AWS CLI tool to create a script, this parameter is set to the zip
	// file name. It must be prepended with the string "fileb://" to indicate that the
	// file data is a binary object. For example: --zip-file
	// fileb://myRealtimeScript.zip.
	ZipFile []byte
	// The location of the Amazon S3 bucket where a zipped file containing your
	// Realtime scripts is stored. The storage location must specify the Amazon S3
	// bucket name, the zip file name (the "key"), and a role ARN that allows Amazon
	// GameLift to access the Amazon S3 storage location. The S3 bucket must be in the
	// same Region where you want to create a new script. By default, Amazon GameLift
	// uploads the latest version of the zip file; if you have S3 object versioning
	// turned on, you can use the ObjectVersion parameter to specify an earlier
	// version.
	StorageLocation *types.S3Location
}

type CreateScriptOutput struct {
	// The newly created script record with a unique script ID and ARN. The new
	// script's storage location reflects an Amazon S3 location: (1) If the script was
	// uploaded from an S3 bucket under your account, the storage location reflects the
	// information that was provided in the CreateScript request; (2) If the script
	// file was uploaded from a local zip file, the storage location reflects an S3
	// location controls by the Amazon GameLift service.
	Script *types.Script

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateVpcPeeringAuthorizationInput struct {
	// A unique identifier for a VPC with resources to be accessed by your Amazon
	// GameLift fleet. The VPC must be in the same Region where your fleet is deployed.
	// Look up a VPC ID using the VPC Dashboard (https://console.aws.amazon.com/vpc/)
	// in the AWS Management Console. Learn more about VPC peering in VPC Peering with
	// Amazon GameLift Fleets
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html).
	PeerVpcId *string
	// A unique identifier for the AWS account that you use to manage your Amazon
	// GameLift fleet. You can find your Account ID in the AWS Management Console under
	// account settings.
	GameLiftAwsAccountId *string
}

type CreateVpcPeeringAuthorizationOutput struct {
	// Details on the requested VPC peering authorization, including expiration.
	VpcPeeringAuthorization *types.VpcPeeringAuthorization

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type CreateVpcPeeringConnectionInput struct {
	// A unique identifier for a fleet. You can use either the fleet ID or ARN value.
	// This tells Amazon GameLift which GameLift VPC to peer with.
	FleetId *string
	// A unique identifier for a VPC with resources to be accessed by your Amazon
	// GameLift fleet. The VPC must be in the same Region where your fleet is deployed.
	// Look up a VPC ID using the VPC Dashboard (https://console.aws.amazon.com/vpc/)
	// in the AWS Management Console. Learn more about VPC peering in VPC Peering with
	// Amazon GameLift Fleets
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html).
	PeerVpcId *string
	// A unique identifier for the AWS account with the VPC that you want to peer your
	// Amazon GameLift fleet with. You can find your Account ID in the AWS Management
	// Console under account settings.
	PeerVpcAwsAccountId *string
}

type CreateVpcPeeringConnectionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteAliasInput struct {
	// A unique identifier of the alias that you want to delete. You can use either the
	// alias ID or ARN value.
	AliasId *string
}

type DeleteAliasOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteBuildInput struct {
	// A unique identifier for a build to delete. You can use either the build ID or
	// ARN value.
	BuildId *string
}

type DeleteBuildOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteFleetInput struct {
	// A unique identifier for a fleet to be deleted. You can use either the fleet ID
	// or ARN value.
	FleetId *string
}

type DeleteFleetOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteGameServerGroupInput struct {
	// The type of delete to perform. Options include:
	//
	//     * SAFE_DELETE – Terminates
	// the game server group and EC2 Auto Scaling group only when it has no game
	// servers that are in IN_USE status.
	//
	//     * FORCE_DELETE – Terminates the game
	// server group, including all active game servers regardless of their utilization
	// status, and the EC2 Auto Scaling group.
	//
	//     * RETAIN – Does a safe delete of
	// the game server group but retains the EC2 Auto Scaling group as is.
	DeleteOption types.GameServerGroupDeleteOption
	// The unique identifier of the game server group to delete. Use either the
	// GameServerGroup () name or ARN value.
	GameServerGroupName *string
}

type DeleteGameServerGroupOutput struct {
	// An object that describes the deleted game server group resource, with status
	// updated to DELETE_SCHEDULED.
	GameServerGroup *types.GameServerGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteGameSessionQueueInput struct {
	// A descriptive label that is associated with game session queue. Queue names must
	// be unique within each Region. You can use either the queue ID or ARN value.
	Name *string
}

type DeleteGameSessionQueueOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteMatchmakingConfigurationInput struct {
	// A unique identifier for a matchmaking configuration. You can use either the
	// configuration name or ARN value.
	Name *string
}

type DeleteMatchmakingConfigurationOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteMatchmakingRuleSetInput struct {
	// A unique identifier for a matchmaking rule set to be deleted. (Note: The rule
	// set name is different from the optional "name" field in the rule set body.) You
	// can use either the rule set name or ARN value.
	Name *string
}

type DeleteMatchmakingRuleSetOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteScalingPolicyInput struct {
	// A descriptive label that is associated with a scaling policy. Policy names do
	// not need to be unique.
	Name *string
	// A unique identifier for a fleet to be deleted. You can use either the fleet ID
	// or ARN value.
	FleetId *string
}

type DeleteScalingPolicyOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteScriptInput struct {
	// A unique identifier for a Realtime script to delete. You can use either the
	// script ID or ARN value.
	ScriptId *string
}

type DeleteScriptOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteVpcPeeringAuthorizationInput struct {
	// A unique identifier for the AWS account that you use to manage your Amazon
	// GameLift fleet. You can find your Account ID in the AWS Management Console under
	// account settings.
	GameLiftAwsAccountId *string
	// A unique identifier for a VPC with resources to be accessed by your Amazon
	// GameLift fleet. The VPC must be in the same Region where your fleet is deployed.
	// Look up a VPC ID using the VPC Dashboard (https://console.aws.amazon.com/vpc/)
	// in the AWS Management Console. Learn more about VPC peering in VPC Peering with
	// Amazon GameLift Fleets
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/vpc-peering.html).
	PeerVpcId *string
}

type DeleteVpcPeeringAuthorizationOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeleteVpcPeeringConnectionInput struct {
	// A unique identifier for a VPC peering connection. This value is included in the
	// VpcPeeringConnection () object, which can be retrieved by calling
	// DescribeVpcPeeringConnections ().
	VpcPeeringConnectionId *string
	// A unique identifier for a fleet. This fleet specified must match the fleet
	// referenced in the VPC peering connection record. You can use either the fleet ID
	// or ARN value.
	FleetId *string
}

type DeleteVpcPeeringConnectionOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DeregisterGameServerInput struct {
	// An identifier for the game server group where the game server to be
	// de-registered is running. Use either the GameServerGroup () name or ARN value.
	GameServerGroupName *string
	// The identifier for the game server to be de-registered.
	GameServerId *string
}

type DeregisterGameServerOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeAliasInput struct {
	// The unique identifier for the fleet alias that you want to retrieve. You can use
	// either the alias ID or ARN value.
	AliasId *string
}

type DescribeAliasOutput struct {
	// The requested alias resource.
	Alias *types.Alias

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeBuildInput struct {
	// A unique identifier for a build to retrieve properties for. You can use either
	// the build ID or ARN value.
	BuildId *string
}

type DescribeBuildOutput struct {
	// Set of properties describing the requested build.
	Build *types.Build

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeEC2InstanceLimitsInput struct {
	// Name of an EC2 instance type that is supported in Amazon GameLift. A fleet
	// instance type determines the computing resources of each instance in the fleet,
	// including CPU, memory, storage, and networking capacity. Amazon GameLift
	// supports the following EC2 instance types. See Amazon EC2 Instance Types
	// (http://aws.amazon.com/ec2/instance-types/) for detailed descriptions. Leave
	// this parameter blank to retrieve limits for all types.
	EC2InstanceType types.EC2InstanceType
}

type DescribeEC2InstanceLimitsOutput struct {
	// The maximum number of instances for the specified instance type.
	EC2InstanceLimits []*types.EC2InstanceLimit

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeFleetAttributesInput struct {
	// A list of unique fleet identifiers to retrieve attributes for. You can use
	// either the fleet ID or ARN value. To retrieve attributes for all current fleets,
	// do not include this parameter. If the list of fleet identifiers includes fleets
	// that don't currently exist, the request succeeds but no attributes for that
	// fleet are returned.
	FleetIds []*string
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages. This parameter is ignored when the
	// request specifies one or a list of fleet IDs.
	Limit *int32
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value. This parameter is ignored
	// when the request specifies one or a list of fleet IDs.
	NextToken *string
}

type DescribeFleetAttributesOutput struct {
	// A collection of objects containing attribute metadata for each requested fleet
	// ID. Attribute objects are returned only for fleets that currently exist.
	FleetAttributes []*types.FleetAttributes
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeFleetCapacityInput struct {
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages. This parameter is ignored when the
	// request specifies one or a list of fleet IDs.
	Limit *int32
	// A unique identifier for a fleet(s) to retrieve capacity information for. You can
	// use either the fleet ID or ARN value.
	FleetIds []*string
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value. This parameter is ignored
	// when the request specifies one or a list of fleet IDs.
	NextToken *string
}

type DescribeFleetCapacityOutput struct {
	// A collection of objects containing capacity information for each requested fleet
	// ID. Leave this parameter empty to retrieve capacity information for all fleets.
	FleetCapacity []*types.FleetCapacity
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeFleetEventsInput struct {
	// Most recent date to retrieve event logs for. If no end time is specified, this
	// call returns entries from the specified start time up to the present. Format is
	// a number expressed in Unix time as milliseconds (ex: "1469498468.057").
	EndTime *time.Time
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
	// Earliest date to retrieve event logs for. If no start time is specified, this
	// call returns entries starting from when the fleet was created to the specified
	// end time. Format is a number expressed in Unix time as milliseconds (ex:
	// "1469498468.057").
	StartTime *time.Time
	// A unique identifier for a fleet to get event logs for. You can use either the
	// fleet ID or ARN value.
	FleetId *string
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
}

type DescribeFleetEventsOutput struct {
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string
	// A collection of objects containing event log entries for the specified fleet.
	Events []*types.Event

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeFleetPortSettingsInput struct {
	// A unique identifier for a fleet to retrieve port settings for. You can use
	// either the fleet ID or ARN value.
	FleetId *string
}

type DescribeFleetPortSettingsOutput struct {
	// The port settings for the requested fleet ID.
	InboundPermissions []*types.IpPermission

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeFleetUtilizationInput struct {
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages. This parameter is ignored when the
	// request specifies one or a list of fleet IDs.
	Limit *int32
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value. This parameter is ignored
	// when the request specifies one or a list of fleet IDs.
	NextToken *string
	// A unique identifier for a fleet(s) to retrieve utilization data for. You can use
	// either the fleet ID or ARN value. To retrieve attributes for all current fleets,
	// do not include this parameter. If the list of fleet identifiers includes fleets
	// that don't currently exist, the request succeeds but no attributes for that
	// fleet are returned.
	FleetIds []*string
}

type DescribeFleetUtilizationOutput struct {
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string
	// A collection of objects containing utilization information for each requested
	// fleet ID.
	FleetUtilization []*types.FleetUtilization

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeGameServerGroupInput struct {
	// The unique identifier for the game server group being requested. Use either the
	// GameServerGroup () name or ARN value.
	GameServerGroupName *string
}

type DescribeGameServerGroupOutput struct {
	// An object that describes the requested game server group resource.
	GameServerGroup *types.GameServerGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeGameServerInput struct {
	// The identifier for the game server to be retrieved.
	GameServerId *string
	// An identifier for the game server group where the game server is running. Use
	// either the GameServerGroup () name or ARN value.
	GameServerGroupName *string
}

type DescribeGameServerOutput struct {
	// Object that describes the requested game server resource.
	GameServer *types.GameServer

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeGameSessionDetailsInput struct {
	// A unique identifier for a fleet to retrieve all game sessions active on the
	// fleet. You can use either the fleet ID or ARN value.
	FleetId *string
	// A unique identifier for an alias associated with the fleet to retrieve all game
	// sessions for. You can use either the alias ID or ARN value.
	AliasId *string
	// Game session status to filter results on. Possible game session statuses include
	// ACTIVE, TERMINATED, ACTIVATING and TERMINATING (the last two are transitory).
	StatusFilter *string
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
	// A unique identifier for the game session to retrieve.
	GameSessionId *string
}

type DescribeGameSessionDetailsOutput struct {
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string
	// A collection of objects containing game session properties and the protection
	// policy currently in force for each session matching the request.
	GameSessionDetails []*types.GameSessionDetail

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeGameSessionPlacementInput struct {
	// A unique identifier for a game session placement to retrieve.
	PlacementId *string
}

type DescribeGameSessionPlacementOutput struct {
	// Object that describes the requested game session placement.
	GameSessionPlacement *types.GameSessionPlacement

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeGameSessionQueuesInput struct {
	// A list of queue names to retrieve information for. You can use either the queue
	// ID or ARN value. To request settings for all queues, leave this parameter empty.
	Names []*string
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
	// 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 action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
}

type DescribeGameSessionQueuesOutput struct {
	// A collection of objects that describe the requested game session queues.
	GameSessionQueues []*types.GameSessionQueue
	// A token that indicates where to resume retrieving results on the next call to
	// this action. If no token is returned, these results represent the end of the
	// list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeGameSessionsInput struct {
	// A unique identifier for a fleet to retrieve all game sessions for. You can use
	// either the fleet ID or ARN value.
	FleetId *string
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
	// A unique identifier for the game session to retrieve.
	GameSessionId *string
	// Game session status to filter results on. Possible game session statuses include
	// ACTIVE, TERMINATED, ACTIVATING, and TERMINATING (the last two are transitory).
	StatusFilter *string
	// A unique identifier for an alias associated with the fleet to retrieve all game
	// sessions for. You can use either the alias ID or ARN value.
	AliasId *string
}

type DescribeGameSessionsOutput struct {
	// A collection of objects containing game session properties for each session
	// matching the request.
	GameSessions []*types.GameSession
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeInstancesInput struct {
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
	// A unique identifier for a fleet to retrieve instance information for. You can
	// use either the fleet ID or ARN value.
	FleetId *string
	// A unique identifier for an instance to retrieve. Specify an instance ID or leave
	// blank to retrieve all instances in the fleet.
	InstanceId *string
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
}

type DescribeInstancesOutput struct {
	// A collection of objects containing properties for each instance returned.
	Instances []*types.Instance
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeMatchmakingConfigurationsInput struct {
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages. This parameter is limited to 10.
	Limit *int32
	// 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 action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
	// A unique identifier for a matchmaking rule set. You can use either the rule set
	// name or ARN value. Use this parameter to retrieve all matchmaking configurations
	// that use this rule set.
	RuleSetName *string
	// A unique identifier for a matchmaking configuration(s) to retrieve. You can use
	// either the configuration name or ARN value. To request all existing
	// configurations, leave this parameter empty.
	Names []*string
}

type DescribeMatchmakingConfigurationsOutput struct {
	// A token that indicates where to resume retrieving results on the next call to
	// this action. If no token is returned, these results represent the end of the
	// list.
	NextToken *string
	// A collection of requested matchmaking configurations.
	Configurations []*types.MatchmakingConfiguration

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeMatchmakingInput struct {
	// A unique identifier for a matchmaking ticket. You can include up to 10 ID
	// values.
	TicketIds []*string
}

type DescribeMatchmakingOutput struct {
	// A collection of existing matchmaking ticket objects matching the request.
	TicketList []*types.MatchmakingTicket

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeMatchmakingRuleSetsInput struct {
	// A list of one or more matchmaking rule set names to retrieve details for. (Note:
	// The rule set name is different from the optional "name" field in the rule set
	// body.) You can use either the rule set name or ARN value.
	Names []*string
	// 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 action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
}

type DescribeMatchmakingRuleSetsOutput struct {
	// A collection of requested matchmaking rule set objects.
	RuleSets []*types.MatchmakingRuleSet
	// A token that indicates where to resume retrieving results on the next call to
	// this action. If no token is returned, these results represent the end of the
	// list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribePlayerSessionsInput struct {
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages. If a player session ID is specified,
	// this parameter is ignored.
	Limit *int32
	// A unique identifier for a player to retrieve player sessions for.
	PlayerId *string
	// Player session status to filter results on. Possible player session statuses
	// include the following:
	//
	//     * RESERVED -- The player session request has been
	// received, but the player has not yet connected to the server process and/or been
	// validated.
	//
	//     * ACTIVE -- The player has been validated by the server process
	// and is currently connected.
	//
	//     * COMPLETED -- The player connection has been
	// dropped.
	//
	//     * TIMEDOUT -- A player session request was received, but the
	// player did not connect and/or was not validated within the timeout limit (60
	// seconds).
	PlayerSessionStatusFilter *string
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value. If a player session ID is
	// specified, this parameter is ignored.
	NextToken *string
	// A unique identifier for the game session to retrieve player sessions for.
	GameSessionId *string
	// A unique identifier for a player session to retrieve.
	PlayerSessionId *string
}

type DescribePlayerSessionsOutput struct {
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string
	// A collection of objects containing properties for each player session that
	// matches the request.
	PlayerSessions []*types.PlayerSession

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeRuntimeConfigurationInput struct {
	// A unique identifier for a fleet to get the runtime configuration for. You can
	// use either the fleet ID or ARN value.
	FleetId *string
}

type DescribeRuntimeConfigurationOutput struct {
	// Instructions describing how server processes should be launched and maintained
	// on each instance in the fleet.
	RuntimeConfiguration *types.RuntimeConfiguration

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeScalingPoliciesInput struct {
	// A unique identifier for a fleet to retrieve scaling policies for. You can use
	// either the fleet ID or ARN value.
	FleetId *string
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
	// Scaling policy status to filter results on. A scaling policy is only in force
	// when in an ACTIVE status.
	//
	//     * ACTIVE -- The scaling policy is currently in
	// force.
	//
	//     * UPDATEREQUESTED -- A request to update the scaling policy has been
	// received.
	//
	//     * UPDATING -- A change is being made to the scaling policy.
	//
	//
	// * DELETEREQUESTED -- A request to delete the scaling policy has been received.
	//
	//
	// * DELETING -- The scaling policy is being deleted.
	//
	//     * DELETED -- The scaling
	// policy has been deleted.
	//
	//     * ERROR -- An error occurred in creating the
	// policy. It should be removed and recreated.
	StatusFilter types.ScalingStatusType
}

type DescribeScalingPoliciesOutput struct {
	// A collection of objects containing the scaling policies matching the request.
	ScalingPolicies []*types.ScalingPolicy
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeScriptInput struct {
	// A unique identifier for a Realtime script to retrieve properties for. You can
	// use either the script ID or ARN value.
	ScriptId *string
}

type DescribeScriptOutput struct {
	// A set of properties describing the requested script.
	Script *types.Script

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeVpcPeeringAuthorizationsInput struct {
}

type DescribeVpcPeeringAuthorizationsOutput struct {
	// A collection of objects that describe all valid VPC peering operations for the
	// current AWS account.
	VpcPeeringAuthorizations []*types.VpcPeeringAuthorization

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type DescribeVpcPeeringConnectionsInput struct {
	// A unique identifier for a fleet. You can use either the fleet ID or ARN value.
	FleetId *string
}

type DescribeVpcPeeringConnectionsOutput struct {
	// A collection of VPC peering connection records that match the request.
	VpcPeeringConnections []*types.VpcPeeringConnection

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type EndpointResolver interface {
	ResolveEndpoint(region string, options ResolverOptions) (aws.Endpoint, error)
}

type EndpointResolverFunc func(region string, options ResolverOptions) (aws.Endpoint, error)

type GetGameSessionLogUrlInput struct {
	// A unique identifier for the game session to get logs for.
	GameSessionId *string
}

type GetGameSessionLogUrlOutput struct {
	// Location of the requested game session logs, available for download. This URL is
	// valid for 15 minutes, after which S3 will reject any download request using this
	// URL. You can request a new URL any time within the 14-day period that the logs
	// are retained.
	PreSignedUrl *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type GetInstanceAccessInput struct {
	// A unique identifier for a fleet that contains the instance you want access to.
	// You can use either the fleet ID or ARN value. The fleet can be in any of the
	// following statuses: ACTIVATING, ACTIVE, or ERROR. Fleets with an ERROR status
	// may be accessible for a short time before they are deleted.
	FleetId *string
	// A unique identifier for an instance you want to get access to. You can access an
	// instance in any status.
	InstanceId *string
}

type GetInstanceAccessOutput struct {
	// The connection information for a fleet instance, including IP address and access
	// credentials.
	InstanceAccess *types.InstanceAccess

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type HTTPClient interface {
	Do(*http.Request) (*http.Response, error)
}

type HTTPSignerV4 interface {
	SignHTTP(ctx context.Context, credentials aws.Credentials, r *http.Request, payloadHash string, service string, region string, signingTime time.Time) error
}

type ListAliasesInput struct {
	// The routing type to filter results on. Use this parameter to retrieve only
	// aliases with a certain routing type. To retrieve all aliases, leave this
	// parameter empty. Possible routing types include the following:
	//
	//     * SIMPLE --
	// The alias resolves to one specific fleet. Use this type when routing to active
	// fleets.
	//
	//     * TERMINAL -- The alias does not resolve to a fleet but instead can
	// be used to display a message to the user. A terminal alias throws a
	// TerminalRoutingStrategyException with the RoutingStrategy () message embedded.
	RoutingStrategyType types.RoutingStrategyType
	// A descriptive label that is associated with an alias. Alias names do not need to
	// be unique.
	Name *string
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
	// 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 action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
}

type ListAliasesOutput struct {
	// A token that indicates where to resume retrieving results on the next call to
	// this action. If no token is returned, these results represent the end of the
	// list.
	NextToken *string
	// A collection of alias resources that match the request parameters.
	Aliases []*types.Alias

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListBuildsInput struct {
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
	// Build status to filter results by. To retrieve all builds, leave this parameter
	// empty. Possible build statuses include the following:
	//
	//     * INITIALIZED -- A
	// new build has been defined, but no files have been uploaded. You cannot create
	// fleets for builds that are in this status. When a build is successfully created,
	// the build status is set to this value.
	//
	//     * READY -- The game build has been
	// successfully uploaded. You can now create new fleets for this build.
	//
	//     *
	// FAILED -- The game build upload failed. You cannot create new fleets for this
	// build.
	Status types.BuildStatus
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
}

type ListBuildsOutput struct {
	// A collection of build resources that match the request.
	Builds []*types.Build
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListFleetsInput struct {
	// A unique identifier for a Realtime script to return fleets for. Use this
	// parameter to return only fleets using a specified script. Use either the script
	// ID or ARN value. To retrieve all fleets, leave this parameter empty.
	ScriptId *string
	// A unique identifier for a build to return fleets for. Use this parameter to
	// return only fleets using a specified build. Use either the build ID or ARN
	// value. To retrieve all fleets, do not include either a BuildId and ScriptID
	// parameter.
	BuildId *string
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
}

type ListFleetsOutput struct {
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string
	// Set of fleet IDs matching the list request. You can retrieve additional
	// information about all returned fleets by passing this result set to a call to
	// DescribeFleetAttributes (), DescribeFleetCapacity (), or
	// DescribeFleetUtilization ().
	FleetIds []*string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListGameServerGroupsInput struct {
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
	// 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 action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
}

type ListGameServerGroupsOutput struct {
	// A collection of game server group objects that match the request.
	GameServerGroups []*types.GameServerGroup
	// A token that indicates where to resume retrieving results on the next call to
	// this action. If no token is returned, these results represent the end of the
	// list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListGameServersInput struct {
	// 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 action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
	// Indicates how to sort the returned data based on the game servers' custom key
	// sort value. If this parameter is left empty, the list of game servers is
	// returned in no particular order.
	SortOrder types.SortOrder
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
	// An identifier for the game server group for the game server you want to list.
	// Use either the GameServerGroup () name or ARN value.
	GameServerGroupName *string
}

type ListGameServersOutput struct {
	// A collection of game server objects that match the request.
	GameServers []*types.GameServer
	// A token that indicates where to resume retrieving results on the next call to
	// this action. If no token is returned, these results represent the end of the
	// list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListScriptsInput struct {
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages.
	Limit *int32
	// 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 action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
}

type ListScriptsOutput struct {
	// A set of properties describing the requested script.
	Scripts []*types.Script
	// A token that indicates where to resume retrieving results on the next call to
	// this action. If no token is returned, these results represent the end of the
	// list.
	NextToken *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ListTagsForResourceInput struct {
	// The Amazon Resource Name (ARN
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)) that is
	// assigned to and uniquely identifies the GameLift resource that you want to
	// retrieve tags for. GameLift resource ARNs are included in the data object for
	// the resource, which can be retrieved by calling a List or Describe action for
	// the resource type.
	ResourceARN *string
}

type ListTagsForResourceOutput struct {
	// The collection of tags that have been assigned to the specified resource.
	Tags []*types.Tag

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type Options struct {
	// Set of options to modify how an operation is invoked. These apply to all
	// operations invoked for this client. Use functional options on operation call to
	// modify this list for per operation behavior.
	APIOptions []func(*middleware.Stack) error

	// The credentials object to use when signing requests.
	Credentials aws.CredentialsProvider

	// The endpoint options to be used when attempting to resolve an endpoint.
	EndpointOptions ResolverOptions

	// The service endpoint resolver.
	EndpointResolver EndpointResolver

	// Signature Version 4 (SigV4) Signer
	HTTPSignerV4 HTTPSignerV4

	// The region to send requests to. (Required)
	Region string

	// Retryer guides how HTTP requests should be retried in case of recoverable
	// failures. When nil the API client will use a default retryer.
	Retryer retry.Retryer

	// The HTTP client to invoke API calls with. Defaults to client's default HTTP
	// implementation if nil.
	HTTPClient HTTPClient
}

type PutScalingPolicyInput struct {
	// Amount of adjustment to make, based on the scaling adjustment type.
	ScalingAdjustment *int32
	// A descriptive label that is associated with a scaling policy. Policy names do
	// not need to be unique. A fleet can have only one scaling policy with the same
	// name.
	Name *string
	// The type of adjustment to make to a fleet's instance count (see FleetCapacity
	// ()):
	//
	//     * ChangeInCapacity -- add (or subtract) the scaling adjustment value
	// from the current instance count. Positive values scale up while negative values
	// scale down.
	//
	//     * ExactCapacity -- set the instance count to the scaling
	// adjustment value.
	//
	//     * PercentChangeInCapacity -- increase or reduce the
	// current instance count by the scaling adjustment, read as a percentage. Positive
	// values scale up while negative values scale down; for example, a value of "-10"
	// scales the fleet down by 10%.
	ScalingAdjustmentType types.ScalingAdjustmentType
	// Metric value used to trigger a scaling event.
	Threshold *float64
	// Comparison operator to use when measuring the metric against the threshold
	// value.
	ComparisonOperator types.ComparisonOperatorType
	// The type of scaling policy to create. For a target-based policy, set the
	// parameter MetricName to 'PercentAvailableGameSessions' and specify a
	// TargetConfiguration. For a rule-based policy set the following parameters:
	// MetricName, ComparisonOperator, Threshold, EvaluationPeriods,
	// ScalingAdjustmentType, and ScalingAdjustment.
	PolicyType types.PolicyType
	// The settings for a target-based scaling policy.
	TargetConfiguration *types.TargetConfiguration
	// Length of time (in minutes) the metric must be at or beyond the threshold before
	// a scaling event is triggered.
	EvaluationPeriods *int32
	// Name of the Amazon GameLift-defined metric that is used to trigger a scaling
	// adjustment. For detailed descriptions of fleet metrics, see Monitor Amazon
	// GameLift with Amazon CloudWatch
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/monitoring-cloudwatch.html).
	//
	//
	// * ActivatingGameSessions -- Game sessions in the process of being created.
	//
	//
	// * ActiveGameSessions -- Game sessions that are currently running.
	//
	//     *
	// ActiveInstances -- Fleet instances that are currently running at least one game
	// session.
	//
	//     * AvailableGameSessions -- Additional game sessions that fleet
	// could host simultaneously, given current capacity.
	//
	//     *
	// AvailablePlayerSessions -- Empty player slots in currently active game sessions.
	// This includes game sessions that are not currently accepting players. Reserved
	// player slots are not included.
	//
	//     * CurrentPlayerSessions -- Player slots in
	// active game sessions that are being used by a player or are reserved for a
	// player.
	//
	//     * IdleInstances -- Active instances that are currently hosting zero
	// game sessions.
	//
	//     * PercentAvailableGameSessions -- Unused percentage of the
	// total number of game sessions that a fleet could host simultaneously, given
	// current capacity. Use this metric for a target-based scaling policy.
	//
	//     *
	// PercentIdleInstances -- Percentage of the total number of active instances that
	// are hosting zero game sessions.
	//
	//     * QueueDepth -- Pending game session
	// placement requests, in any queue, where the current fleet is the top-priority
	// destination.
	//
	//     * WaitTime -- Current wait time for pending game session
	// placement requests, in any queue, where the current fleet is the top-priority
	// destination.
	MetricName types.MetricName
	// A unique identifier for a fleet to apply this policy to. You can use either the
	// fleet ID or ARN value. The fleet cannot be in any of the following statuses:
	// ERROR or DELETING.
	FleetId *string
}

type PutScalingPolicyOutput struct {
	// A descriptive label that is associated with a scaling policy. Policy names do
	// not need to be unique.
	Name *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type RegisterGameServerInput struct {
	// A list of labels to assign to the new game server resource. Tags are
	// developer-defined key-value pairs. Tagging AWS resources are useful for resource
	// management, access management, and cost allocation. For more information, see
	// Tagging AWS Resources
	// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) in the AWS
	// General Reference. Once the resource is created, you can use TagResource (),
	// UntagResource (), and ListTagsForResource () to add, remove, and view tags. The
	// maximum tag limit may be lower than stated. See the AWS General Reference for
	// actual tagging limits.
	Tags []*types.Tag
	// A custom string that uniquely identifies the new game server. Game server IDs
	// are developer-defined and must be unique across all game server groups in your
	// AWS account.
	GameServerId *string
	// A set of custom game server properties, formatted as a single string value. This
	// data is passed to a game client or service when it requests information on a
	// game servers using ListGameServers () or ClaimGameServer ().
	GameServerData *string
	// A game server tag that can be used to request sorted lists of game servers using
	// ListGameServers (). Custom sort keys are developer-defined based on how you want
	// to organize the retrieved game server information.
	CustomSortKey *string
	// Information needed to make inbound client connections to the game server. This
	// might include IP address and port, DNS name, etc.
	ConnectionInfo *string
	// The unique identifier for the instance where the game server is running. This ID
	// is available in the instance metadata.
	InstanceId *string
	// An identifier for the game server group where the game server is running. You
	// can use either the GameServerGroup () name or ARN value.
	GameServerGroupName *string
}

type RegisterGameServerOutput struct {
	// Object that describes the newly created game server resource.
	GameServer *types.GameServer

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type RequestUploadCredentialsInput struct {
	// A unique identifier for a build to get credentials for. You can use either the
	// build ID or ARN value.
	BuildId *string
}

type RequestUploadCredentialsOutput struct {
	// AWS credentials required when uploading a game build to the storage location.
	// These credentials have a limited lifespan and are valid only for the build they
	// were issued for.
	UploadCredentials *types.AwsCredentials
	// Amazon S3 path and key, identifying where the game build files are stored.
	StorageLocation *types.S3Location

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ResolveAliasInput struct {
	// The unique identifier of the alias that you want to retrieve a fleet ID for. You
	// can use either the alias ID or ARN value.
	AliasId *string
}

type ResolveAliasOutput struct {
	// The fleet identifier that the alias is pointing to.
	FleetId *string
	// The Amazon Resource Name (ARN
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html))
	// associated with the GameLift fleet resource that this alias points to.
	FleetArn *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type ResolveEndpoint struct {
	Resolver EndpointResolver
	Options  ResolverOptions
}

type ResolveEndpointMiddlewareOptions interface {
	GetEndpointResolver() EndpointResolver
	GetEndpointOptions() ResolverOptions
}

type ResolverOptions = internalendpoints.Options

type ResumeGameServerGroupInput struct {
	// The action to resume for this game server group.
	ResumeActions []types.GameServerGroupAction
	// The unique identifier of the game server group to resume activity on. Use either
	// the GameServerGroup () name or ARN value.
	GameServerGroupName *string
}

type ResumeGameServerGroupOutput struct {
	// An object that describes the game server group resource, with the
	// SuspendedActions property updated to reflect the resumed activity.
	GameServerGroup *types.GameServerGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SearchGameSessionsInput struct {
	// String containing the search criteria for the session search. If no filter
	// expression is included, the request returns results for all game sessions in the
	// fleet that are in ACTIVE status. A filter expression can contain one or multiple
	// conditions. Each condition consists of the following:
	//
	//     * Operand -- Name of
	// a game session attribute. Valid values are gameSessionName, gameSessionId,
	// gameSessionProperties, maximumSessions, creationTimeMillis, playerSessionCount,
	// hasAvailablePlayerSessions.
	//
	//     * Comparator -- Valid comparators are: =, <>,
	// <, >, <=, >=.
	//
	//     * Value -- Value to be searched for. Values may be numbers,
	// boolean values (true/false) or strings depending on the operand. String values
	// are case sensitive and must be enclosed in single quotes. Special characters
	// must be escaped. Boolean and string values can only be used with the comparators
	// = and <>. For example, the following filter expression searches on
	// gameSessionName: "FilterExpression": "gameSessionName = 'Matt\\'s Awesome Game
	// 1'".
	//
	// To chain multiple conditions in a single expression, use the logical
	// keywords AND, OR, and NOT and parentheses as needed. For example: x AND y AND
	// NOT z, NOT (x OR y). Session search evaluates conditions from left to right
	// using the following precedence rules:
	//
	//     * =, <>, <, >, <=, >=
	//
	//     *
	// Parentheses
	//
	//     * NOT
	//
	//     * AND
	//
	//     * OR
	//
	// For example, this filter expression
	// retrieves game sessions hosting at least ten players that have an open player
	// slot: "maximumSessions>=10 AND hasAvailablePlayerSessions=true".
	FilterExpression *string
	// Instructions on how to sort the search results. If no sort expression is
	// included, the request returns results in random order. A sort expression
	// consists of the following elements:
	//
	//     * Operand -- Name of a game session
	// attribute. Valid values are gameSessionName, gameSessionId,
	// gameSessionProperties, maximumSessions, creationTimeMillis, playerSessionCount,
	// hasAvailablePlayerSessions.
	//
	//     * Order -- Valid sort orders are ASC
	// (ascending) and DESC (descending).
	//
	// For example, this sort expression returns
	// the oldest active sessions first: "SortExpression": "creationTimeMillis ASC".
	// Results with a null value for the sort operand are returned at the end of the
	// list.
	SortExpression *string
	// Token that indicates the start of the next sequential page of results. Use the
	// token that is returned with a previous call to this action. To start at the
	// beginning of the result set, do not specify a value.
	NextToken *string
	// The maximum number of results to return. Use this parameter with NextToken to
	// get results as a set of sequential pages. The maximum number of results returned
	// is 20, even if this value is not set or is set higher than 20.
	Limit *int32
	// A unique identifier for a fleet to search for active game sessions. You can use
	// either the fleet ID or ARN value. Each request must reference either a fleet ID
	// or alias ID, but not both.
	FleetId *string
	// A unique identifier for an alias associated with the fleet to search for active
	// game sessions. You can use either the alias ID or ARN value. Each request must
	// reference either a fleet ID or alias ID, but not both.
	AliasId *string
}

type SearchGameSessionsOutput struct {
	// Token that indicates where to resume retrieving results on the next call to this
	// action. If no token is returned, these results represent the end of the list.
	NextToken *string
	// A collection of objects containing game session properties for each session
	// matching the request.
	GameSessions []*types.GameSession

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StartFleetActionsInput struct {
	// List of actions to restart on the fleet.
	Actions []types.FleetAction
	// A unique identifier for a fleet to start actions on. You can use either the
	// fleet ID or ARN value.
	FleetId *string
}

type StartFleetActionsOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StartGameSessionPlacementInput struct {
	// Set of custom game session properties, formatted as a single string value. This
	// data is passed to a game server process in the GameSession () object with a
	// request to start a new game session (see Start a Game Session
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)).
	GameSessionData *string
	// A descriptive label that is associated with a game session. Session names do not
	// need to be unique.
	GameSessionName *string
	// Set of custom properties for a game session, formatted as key:value pairs. These
	// properties are passed to a game server process in the GameSession () object with
	// a request to start a new game session (see Start a Game Session
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-sdk-server-api.html#gamelift-sdk-server-startsession)).
	GameProperties []*types.GameProperty
	// Set of values, expressed in milliseconds, indicating 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 can offer the best possible gameplay
	// experience for the players.
	PlayerLatencies []*types.PlayerLatency
	// Set of information on each player to create a player session for.
	DesiredPlayerSessions []*types.DesiredPlayerSession
	// Name of the queue to use to place the new game session. You can use either the
	// queue name or ARN value.
	GameSessionQueueName *string
	// The maximum number of players that can be connected simultaneously to the game
	// session.
	MaximumPlayerSessionCount *int32
	// A unique identifier to assign to the new game session placement. This value is
	// developer-defined. The value must be unique across all Regions and cannot be
	// reused unless you are resubmitting a canceled or timed-out placement request.
	PlacementId *string
}

type StartGameSessionPlacementOutput struct {
	// Object that describes the newly created game session placement. This object
	// includes all the information provided in the request, as well as start/end time
	// stamps and placement status.
	GameSessionPlacement *types.GameSessionPlacement

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StartMatchBackfillInput struct {
	// Match information on all players that are currently assigned to the game
	// session. This information is used by the matchmaker to find new players and add
	// them to the existing game.
	//
	//     * PlayerID, PlayerAttributes, Team -\\- This
	// information is maintained in the GameSession () object, MatchmakerData property,
	// for all players who are currently assigned to the game session. The matchmaker
	// data is in JSON syntax, formatted as a string. For more details, see  Match Data
	// (https://docs.aws.amazon.com/gamelift/latest/developerguide/match-server.html#match-server-data).
	//
	//
	// * LatencyInMs -\\- If the matchmaker uses player latency, include a latency
	// value, in milliseconds, for the Region that the game session is currently in. Do
	// not include latency values for any other Region.
	Players []*types.Player
	// Name of the matchmaker to use for this request. You can use either the
	// configuration name or ARN value. The ARN of the matchmaker that was used with
	// the original game session is listed in the GameSession () object, MatchmakerData
	// property.
	ConfigurationName *string
	// Amazon Resource Name (ARN
	// (https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html))
	// that is assigned to a game session and uniquely identifies it. This is the same
	// as the game session ID.
	GameSessionArn *string
	// A unique identifier for a matchmaking ticket. If no ticket ID is specified here,
	// Amazon GameLift will generate one in the form of a UUID. Use this identifier to
	// track the match backfill ticket status and retrieve match results.
	TicketId *string
}

type StartMatchBackfillOutput struct {
	// Ticket representing the backfill matchmaking request. This object includes the
	// information in the request, ticket status, and match results as generated during
	// the matchmaking process.
	MatchmakingTicket *types.MatchmakingTicket

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StartMatchmakingInput struct {
	// Name of the matchmaking configuration to use for this request. Matchmaking
	// configurations must exist in the same Region as this request. You can use either
	// the configuration name or ARN value.
	ConfigurationName *string
	// A unique identifier for a matchmaking ticket. If no ticket ID is specified here,
	// Amazon GameLift will generate one in the form of a UUID. Use this identifier to
	// track the matchmaking ticket status and retrieve match results.
	TicketId *string
	// Information on each player to be matched. This information must include a player
	// ID, and may contain player attributes and latency data to be used in the
	// matchmaking process. After a successful match, Player objects contain the name
	// of the team the player is assigned to.
	Players []*types.Player
}

type StartMatchmakingOutput struct {
	// Ticket representing the matchmaking request. This object include the information
	// included in the request, ticket status, and match results as generated during
	// the matchmaking process.
	MatchmakingTicket *types.MatchmakingTicket

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StopFleetActionsInput struct {
	// List of actions to suspend on the fleet.
	Actions []types.FleetAction
	// A unique identifier for a fleet to stop actions on. You can use either the fleet
	// ID or ARN value.
	FleetId *string
}

type StopFleetActionsOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StopGameSessionPlacementInput struct {
	// A unique identifier for a game session placement to cancel.
	PlacementId *string
}

type StopGameSessionPlacementOutput struct {
	// Object that describes the canceled game session placement, with CANCELLED status
	// and an end time stamp.
	GameSessionPlacement *types.GameSessionPlacement

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type StopMatchmakingInput struct {
	// A unique identifier for a matchmaking ticket.
	TicketId *string
}

type StopMatchmakingOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type SuspendGameServerGroupInput struct {
	// The action to suspend for this game server group.
	SuspendActions []types.GameServerGroupAction
	// The unique identifier of the game server group to stop activity on. Use either
	// the GameServerGroup () name or ARN value.
	GameServerGroupName *string
}

type SuspendGameServerGroupOutput struct {
	// An object that describes the game server group resource, with the
	// SuspendedActions property updated to reflect the suspended activity.
	GameServerGroup *types.GameServerGroup

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type TagResourceInput struct {
	// A list of one or more tags to assign to the specified GameLift resource. Tags
	// are developer-defined and structured as key-value pairs. The maximum tag limit
	// may be lower than stated. See  Tagging AWS Resources
	// (https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html) for actual
	// tagging limits.
	Tags []*types.Tag
	// The Amazon Resource Name (ARN
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)) that is
	// assigned to and uniquely identifies the GameLift resource that you want to
	// assign tags to. GameLift resource ARNs are included in the data object for the
	// resource, which can be retrieved by calling a List or Describe action for the
	// resource type.
	ResourceARN *string
}

type TagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UntagResourceInput struct {
	// The Amazon Resource Name (ARN
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)) that is
	// assigned to and uniquely identifies the GameLift resource that you want to
	// remove tags from. GameLift resource ARNs are included in the data object for the
	// resource, which can be retrieved by calling a List or Describe action for the
	// resource type.
	ResourceARN *string
	// A list of one or more tag keys to remove from the specified GameLift resource.
	// An AWS resource can have only one tag with a specific tag key, so specifying the
	// tag key identifies which tag to remove.
	TagKeys []*string
}

type UntagResourceOutput struct {
	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateAliasInput struct {
	// The routing configuration, including routing type and fleet target, for the
	// alias.
	RoutingStrategy *types.RoutingStrategy
	// A human-readable description of the alias.
	Description *string
	// A descriptive label that is associated with an alias. Alias names do not need to
	// be unique.
	Name *string
	// A unique identifier for the alias that you want to update. You can use either
	// the alias ID or ARN value.
	AliasId *string
}

type UpdateAliasOutput struct {
	// The updated alias resource.
	Alias *types.Alias

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateBuildInput struct {
	// A unique identifier for a build to update. You can use either the build ID or
	// ARN value.
	BuildId *string
	// Version information that is associated with a build or script. Version strings
	// do not need to be unique.
	Version *string
	// A descriptive label that is associated with a build. Build names do not need to
	// be unique.
	Name *string
}

type UpdateBuildOutput struct {
	// The updated build resource.
	Build *types.Build

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateFleetAttributesInput struct {
	// Names of metric groups to include this fleet in. Amazon CloudWatch uses a fleet
	// metric group is to aggregate metrics from multiple fleets. Use an existing
	// metric group name to add this fleet to the group. Or use a new name to create a
	// new metric group. A fleet can only be included in one metric group at a time.
	MetricGroups []*string
	// A descriptive label that is associated with a fleet. Fleet names do not need to
	// be unique.
	Name *string
	// Game session protection policy to apply to all new instances created in this
	// fleet. Instances that already exist are not affected. You can set protection for
	// individual instances using UpdateGameSession ().
	//
	//     * NoProtection -- The game
	// session can be terminated during a scale-down event.
	//
	//     * FullProtection -- If
	// the game session is in an ACTIVE status, it cannot be terminated during a
	// scale-down event.
	NewGameSessionProtectionPolicy types.ProtectionPolicy
	// Human-readable description of a fleet.
	Description *string
	// A unique identifier for a fleet to update attribute metadata for. You can use
	// either the fleet ID or ARN value.
	FleetId *string
	// Policy that limits the number of game sessions an individual player can create
	// over a span of time.
	ResourceCreationLimitPolicy *types.ResourceCreationLimitPolicy
}

type UpdateFleetAttributesOutput struct {
	// A unique identifier for a fleet that was updated. Use either the fleet ID or ARN
	// value.
	FleetId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateFleetCapacityInput struct {
	// The maximum value allowed for the fleet's instance count. Default if not set is
	// 1.
	MaxSize *int32
	// A unique identifier for a fleet to update capacity for. You can use either the
	// fleet ID or ARN value.
	FleetId *string
	// The minimum value allowed for the fleet's instance count. Default if not set is
	// 0.
	MinSize *int32
	// Number of EC2 instances you want this fleet to host.
	DesiredInstances *int32
}

type UpdateFleetCapacityOutput struct {
	// A unique identifier for a fleet that was updated.
	FleetId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateFleetPortSettingsInput struct {
	// A collection of port settings to be added to the fleet resource.
	InboundPermissionAuthorizations []*types.IpPermission
	// A collection of port settings to be removed from the fleet resource.
	InboundPermissionRevocations []*types.IpPermission
	// A unique identifier for a fleet to update port settings for. You can use either
	// the fleet ID or ARN value.
	FleetId *string
}

type UpdateFleetPortSettingsOutput struct {
	// A unique identifier for a fleet that was updated.
	FleetId *string

	// Metadata pertaining to the operation's result.
	ResultMetadata middleware.Metadata
}

type UpdateGameServerGroupInput struct {
	// The fallback balancing method to use for the game server group when Spot
	// instances in a Region become unavailable or are not viable for game hosting.
	// Once triggered, this method remains active until Spot instances can once again
	// be used. Method options include:
	//
	//     * SPOT_ONLY -- If Spot instances are
	// unavailable, the game server group provides no hosting capacity. No new
	// instances are started, and the existing nonviable Spot instances are terminated
	// (once current gameplay ends) and not replaced.
	//
	//     * SPOT_PREFERRED -- If Spot
	// instances are unavailable, the game server group continues to provide hosting
	// capacity by using On-Demand instances. Existing nonviable Spot instances are
	// terminated (once current gameplay ends) and replaced with new On-Demand
	// instances.
	BalancingStrategy types.BalancingStrategy
	// The Amazon Resource Name (ARN
	// (https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-arn-format.html)) for an IAM
	// role that allows Amazon GameLift to access your EC2 Auto Scaling groups. The
	// submitted role is validated to ensure that it contains the necessary permissions
	// for game server groups.
	RoleArn *string
	// An updated list of EC2 instance types to use when creating instances in the
	// group. The instance definition must specify instance types that are supported by
	// GameLift FleetIQ, and must include at least two instance types. This updated
	// list replaces the entire current list of instance definitions for the game
	// server group. For more information on instance types, see EC2 Instance Types
	// (https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html) in the
	// Amazon EC2 User Guide..
	InstanceDefinitions []*types.InstanceDefinition
	// A flag that indicates whether instances in the game server group are protected
	// from early termination. Unprotected instances that have active game servers
	// running may by terminated during a scale-down event, causing players to be
	// dropped from the game. Protected instances cannot be terminated while there are
	// active game servers running. An exception to this is Spot Instances, which may
	// be terminated by AWS regardless of protection status. This property is set to
	// NO_PROTECTION by default.
	GameServerProtectionPolicy types.GameServerProtectionPolicy
	// The unique identifier of the game server group to update. Use either the
	// GameServerGroup () name or ARN value.
	GameServerGroupName *string
}