import * as pulumi from "@pulumi/pulumi"; import * as inputs from "../types/input"; import * as outputs from "../types/output"; /** * The AWS::GameLift::GameSessionQueue resource creates an Amazon GameLift (GameLift) game session queue. * * ## Example Usage * ### Example * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as aws_native from "@pulumi/aws-native"; * * const queue = new aws_native.gamelift.GameSessionQueue("queue", { * name: "MyGameSessionQueue", * timeoutInSeconds: 60, * notificationTarget: "arn:aws:sns:us-west-2:111122223333:My_Placement_SNS_Topic", * destinations: [ * { * destinationArn: "arn:aws:gamelift:us-west-2:012345678912:fleet/fleet-id", * }, * { * destinationArn: "arn:aws:gamelift:us-west-2:012345678912:alias/alias-id", * }, * ], * playerLatencyPolicies: [{ * maximumIndividualPlayerLatencyMilliseconds: 1000, * policyDurationSeconds: 60, * }], * priorityConfiguration: { * locationOrder: [ * "us-west-2", * "us-east-1", * ], * priorityOrder: [ * aws_native.gamelift.GameSessionQueuePriorityOrderItem.Cost, * aws_native.gamelift.GameSessionQueuePriorityOrderItem.Latency, * aws_native.gamelift.GameSessionQueuePriorityOrderItem.Location, * aws_native.gamelift.GameSessionQueuePriorityOrderItem.Destination, * ], * }, * filterConfiguration: { * allowedLocations: [ * "us-east-1", * "us-west-2", * ], * }, * }); * * ``` * ### Example * * ```typescript * import * as pulumi from "@pulumi/pulumi"; * import * as aws_native from "@pulumi/aws-native"; * * const queueResource = new aws_native.gamelift.GameSessionQueue("queueResource", {name: "MyGameSessionQueue"}); * const matchmakingRuleSetResource = new aws_native.gamelift.MatchmakingRuleSet("matchmakingRuleSetResource", { * name: "MyRuleSet", * ruleSetBody: "{\"name\": \"MyMatchmakingRuleSet\",\"ruleLanguageVersion\": \"1.0\", \"teams\": [{\"name\": \"MyTeam\",\"minPlayers\": 1,\"maxPlayers\": 20}]}", * }); * const matchmakingConfigurationResource = new aws_native.gamelift.MatchmakingConfiguration("matchmakingConfigurationResource", { * name: "MyMatchmakingConfiguration", * acceptanceRequired: true, * acceptanceTimeoutSeconds: 60, * additionalPlayerCount: 8, * backfillMode: aws_native.gamelift.MatchmakingConfigurationBackfillMode.Automatic, * customEventData: "MyCustomEventData", * description: "A basic matchmaking configuration for a GameLift-hosted game", * flexMatchMode: aws_native.gamelift.MatchmakingConfigurationFlexMatchMode.WithQueue, * gameSessionData: "MyGameSessionData", * gameProperties: [ * { * key: "level", * value: "10", * }, * { * key: "gameMode", * value: "hard", * }, * ], * gameSessionQueueArns: [queueResource.arn], * requestTimeoutSeconds: 100, * ruleSetName: matchmakingRuleSetResource.id, * }, { * dependsOn: [ * queueResource, * matchmakingRuleSetResource, * ], * }); * * ``` */ export declare class GameSessionQueue extends pulumi.CustomResource { /** * Get an existing GameSessionQueue resource's state with the given name, ID, and optional extra * properties used to qualify the lookup. * * @param name The _unique_ name of the resulting resource. * @param id The _unique_ provider ID of the resource to lookup. * @param opts Optional settings to control the behavior of the CustomResource. */ static get(name: string, id: pulumi.Input, opts?: pulumi.CustomResourceOptions): GameSessionQueue; /** * Returns true if the given object is an instance of GameSessionQueue. This is designed to work even * when multiple copies of the Pulumi SDK have been loaded into the same process. */ static isInstance(obj: any): obj is GameSessionQueue; /** * The Amazon Resource Name (ARN) that is assigned to a Amazon GameLift game session queue resource and uniquely identifies it. */ readonly arn: pulumi.Output; /** * Information that is added to all events that are related to this game session queue. */ readonly customEventData: pulumi.Output; /** * A list of fleets and/or fleet aliases that can be used to fulfill game session placement requests in the queue. */ readonly destinations: pulumi.Output; /** * A list of locations where a queue is allowed to place new game sessions. */ readonly filterConfiguration: pulumi.Output; /** * A descriptive label that is associated with game session queue. Queue names must be unique within each Region. */ readonly name: pulumi.Output; /** * An SNS topic ARN that is set up to receive game session placement notifications. */ readonly notificationTarget: pulumi.Output; /** * A set of policies that act as a sliding cap on player latency. */ readonly playerLatencyPolicies: pulumi.Output; /** * Custom settings to use when prioritizing destinations and locations for game session placements. */ readonly priorityConfiguration: pulumi.Output; /** * An array of key-value pairs to apply to this resource. */ readonly tags: pulumi.Output; /** * The maximum time, in seconds, that a new game session placement request remains in the queue. */ readonly timeoutInSeconds: pulumi.Output; /** * Create a GameSessionQueue resource with the given unique name, arguments, and options. * * @param name The _unique_ name of the resource. * @param args The arguments to use to populate this resource's properties. * @param opts A bag of options that control this resource's behavior. */ constructor(name: string, args?: GameSessionQueueArgs, opts?: pulumi.CustomResourceOptions); } /** * The set of arguments for constructing a GameSessionQueue resource. */ export interface GameSessionQueueArgs { /** * Information that is added to all events that are related to this game session queue. */ customEventData?: pulumi.Input; /** * A list of fleets and/or fleet aliases that can be used to fulfill game session placement requests in the queue. */ destinations?: pulumi.Input[]>; /** * A list of locations where a queue is allowed to place new game sessions. */ filterConfiguration?: pulumi.Input; /** * A descriptive label that is associated with game session queue. Queue names must be unique within each Region. */ name?: pulumi.Input; /** * An SNS topic ARN that is set up to receive game session placement notifications. */ notificationTarget?: pulumi.Input; /** * A set of policies that act as a sliding cap on player latency. */ playerLatencyPolicies?: pulumi.Input[]>; /** * Custom settings to use when prioritizing destinations and locations for game session placements. */ priorityConfiguration?: pulumi.Input; /** * An array of key-value pairs to apply to this resource. */ tags?: pulumi.Input[]>; /** * The maximum time, in seconds, that a new game session placement request remains in the queue. */ timeoutInSeconds?: pulumi.Input; }