@aws-sdk/client-gamelift 3.50.0 → 3.51.0

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

@@ -0,0 +1,3472 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export declare type AcceptanceType = "ACCEPT" | "REJECT";
+
+export interface AcceptMatchInput {
+    
+    TicketId: string | undefined;
+    
+    PlayerIds: string[] | undefined;
+    
+    AcceptanceType: AcceptanceType | string | undefined;
+}
+export declare namespace AcceptMatchInput {
+    
+    const filterSensitiveLog: (obj: AcceptMatchInput) => any;
+}
+export interface AcceptMatchOutput {
+}
+export declare namespace AcceptMatchOutput {
+    
+    const filterSensitiveLog: (obj: AcceptMatchOutput) => any;
+}
+
+export interface InternalServiceException extends __SmithyException, $MetadataBearer {
+    name: "InternalServiceException";
+    $fault: "server";
+    Message?: string;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface NotFoundException extends __SmithyException, $MetadataBearer {
+    name: "NotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface UnsupportedRegionException extends __SmithyException, $MetadataBearer {
+    name: "UnsupportedRegionException";
+    $fault: "client";
+    Message?: string;
+}
+export declare enum RoutingStrategyType {
+    SIMPLE = "SIMPLE",
+    TERMINAL = "TERMINAL"
+}
+
+export interface RoutingStrategy {
+    
+    Type?: RoutingStrategyType | string;
+    
+    FleetId?: string;
+    
+    Message?: string;
+}
+export declare namespace RoutingStrategy {
+    
+    const filterSensitiveLog: (obj: RoutingStrategy) => any;
+}
+
+export interface Alias {
+    
+    AliasId?: string;
+    
+    Name?: string;
+    
+    AliasArn?: string;
+    
+    Description?: string;
+    
+    RoutingStrategy?: RoutingStrategy;
+    
+    CreationTime?: Date;
+    
+    LastUpdatedTime?: Date;
+}
+export declare namespace Alias {
+    
+    const filterSensitiveLog: (obj: Alias) => any;
+}
+
+export interface AttributeValue {
+    
+    S?: string;
+    
+    N?: number;
+    
+    SL?: string[];
+    
+    SDM?: {
+        [key: string]: number;
+    };
+}
+export declare namespace AttributeValue {
+    
+    const filterSensitiveLog: (obj: AttributeValue) => any;
+}
+
+export interface AwsCredentials {
+    
+    AccessKeyId?: string;
+    
+    SecretAccessKey?: string;
+    
+    SessionToken?: string;
+}
+export declare namespace AwsCredentials {
+    
+    const filterSensitiveLog: (obj: AwsCredentials) => any;
+}
+export declare enum BackfillMode {
+    AUTOMATIC = "AUTOMATIC",
+    MANUAL = "MANUAL"
+}
+export declare enum BalancingStrategy {
+    ON_DEMAND_ONLY = "ON_DEMAND_ONLY",
+    SPOT_ONLY = "SPOT_ONLY",
+    SPOT_PREFERRED = "SPOT_PREFERRED"
+}
+export declare enum OperatingSystem {
+    AMAZON_LINUX = "AMAZON_LINUX",
+    AMAZON_LINUX_2 = "AMAZON_LINUX_2",
+    WINDOWS_2012 = "WINDOWS_2012"
+}
+export declare enum BuildStatus {
+    FAILED = "FAILED",
+    INITIALIZED = "INITIALIZED",
+    READY = "READY"
+}
+
+export interface Build {
+    
+    BuildId?: string;
+    
+    BuildArn?: string;
+    
+    Name?: string;
+    
+    Version?: string;
+    
+    Status?: BuildStatus | string;
+    
+    SizeOnDisk?: number;
+    
+    OperatingSystem?: OperatingSystem | string;
+    
+    CreationTime?: Date;
+}
+export declare namespace Build {
+    
+    const filterSensitiveLog: (obj: Build) => any;
+}
+export declare enum CertificateType {
+    Disabled = "DISABLED",
+    Generated = "GENERATED"
+}
+
+export interface CertificateConfiguration {
+    
+    CertificateType: CertificateType | string | undefined;
+}
+export declare namespace CertificateConfiguration {
+    
+    const filterSensitiveLog: (obj: CertificateConfiguration) => any;
+}
+export interface ClaimGameServerInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    GameServerId?: string;
+    
+    GameServerData?: string;
+}
+export declare namespace ClaimGameServerInput {
+    
+    const filterSensitiveLog: (obj: ClaimGameServerInput) => any;
+}
+export declare enum GameServerClaimStatus {
+    CLAIMED = "CLAIMED"
+}
+export declare enum GameServerUtilizationStatus {
+    AVAILABLE = "AVAILABLE",
+    UTILIZED = "UTILIZED"
+}
+
+export interface GameServer {
+    
+    GameServerGroupName?: string;
+    
+    GameServerGroupArn?: string;
+    
+    GameServerId?: string;
+    
+    InstanceId?: string;
+    
+    ConnectionInfo?: string;
+    
+    GameServerData?: string;
+    
+    ClaimStatus?: GameServerClaimStatus | string;
+    
+    UtilizationStatus?: GameServerUtilizationStatus | string;
+    
+    RegistrationTime?: Date;
+    
+    LastClaimTime?: Date;
+    
+    LastHealthCheckTime?: Date;
+}
+export declare namespace GameServer {
+    
+    const filterSensitiveLog: (obj: GameServer) => any;
+}
+export interface ClaimGameServerOutput {
+    
+    GameServer?: GameServer;
+}
+export declare namespace ClaimGameServerOutput {
+    
+    const filterSensitiveLog: (obj: ClaimGameServerOutput) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface OutOfCapacityException extends __SmithyException, $MetadataBearer {
+    name: "OutOfCapacityException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface UnauthorizedException extends __SmithyException, $MetadataBearer {
+    name: "UnauthorizedException";
+    $fault: "client";
+    Message?: string;
+}
+export declare enum ComparisonOperatorType {
+    GreaterThanOrEqualToThreshold = "GreaterThanOrEqualToThreshold",
+    GreaterThanThreshold = "GreaterThanThreshold",
+    LessThanOrEqualToThreshold = "LessThanOrEqualToThreshold",
+    LessThanThreshold = "LessThanThreshold"
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface CreateAliasInput {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    RoutingStrategy: RoutingStrategy | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateAliasInput {
+    
+    const filterSensitiveLog: (obj: CreateAliasInput) => any;
+}
+
+export interface CreateAliasOutput {
+    
+    Alias?: Alias;
+}
+export declare namespace CreateAliasOutput {
+    
+    const filterSensitiveLog: (obj: CreateAliasOutput) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface TaggingFailedException extends __SmithyException, $MetadataBearer {
+    name: "TaggingFailedException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface S3Location {
+    
+    Bucket?: string;
+    
+    Key?: string;
+    
+    RoleArn?: string;
+    
+    ObjectVersion?: string;
+}
+export declare namespace S3Location {
+    
+    const filterSensitiveLog: (obj: S3Location) => any;
+}
+
+export interface CreateBuildInput {
+    
+    Name?: string;
+    
+    Version?: string;
+    
+    StorageLocation?: S3Location;
+    
+    OperatingSystem?: OperatingSystem | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateBuildInput {
+    
+    const filterSensitiveLog: (obj: CreateBuildInput) => any;
+}
+
+export interface CreateBuildOutput {
+    
+    Build?: Build;
+    
+    UploadCredentials?: AwsCredentials;
+    
+    StorageLocation?: S3Location;
+}
+export declare namespace CreateBuildOutput {
+    
+    const filterSensitiveLog: (obj: CreateBuildOutput) => any;
+}
+export declare enum IpProtocol {
+    TCP = "TCP",
+    UDP = "UDP"
+}
+
+export interface IpPermission {
+    
+    FromPort: number | undefined;
+    
+    ToPort: number | undefined;
+    
+    IpRange: string | undefined;
+    
+    Protocol: IpProtocol | string | undefined;
+}
+export declare namespace IpPermission {
+    
+    const filterSensitiveLog: (obj: IpPermission) => any;
+}
+export declare type EC2InstanceType = "c3.2xlarge" | "c3.4xlarge" | "c3.8xlarge" | "c3.large" | "c3.xlarge" | "c4.2xlarge" | "c4.4xlarge" | "c4.8xlarge" | "c4.large" | "c4.xlarge" | "c5.12xlarge" | "c5.18xlarge" | "c5.24xlarge" | "c5.2xlarge" | "c5.4xlarge" | "c5.9xlarge" | "c5.large" | "c5.xlarge" | "c5a.12xlarge" | "c5a.16xlarge" | "c5a.24xlarge" | "c5a.2xlarge" | "c5a.4xlarge" | "c5a.8xlarge" | "c5a.large" | "c5a.xlarge" | "m3.2xlarge" | "m3.large" | "m3.medium" | "m3.xlarge" | "m4.10xlarge" | "m4.2xlarge" | "m4.4xlarge" | "m4.large" | "m4.xlarge" | "m5.12xlarge" | "m5.16xlarge" | "m5.24xlarge" | "m5.2xlarge" | "m5.4xlarge" | "m5.8xlarge" | "m5.large" | "m5.xlarge" | "m5a.12xlarge" | "m5a.16xlarge" | "m5a.24xlarge" | "m5a.2xlarge" | "m5a.4xlarge" | "m5a.8xlarge" | "m5a.large" | "m5a.xlarge" | "r3.2xlarge" | "r3.4xlarge" | "r3.8xlarge" | "r3.large" | "r3.xlarge" | "r4.16xlarge" | "r4.2xlarge" | "r4.4xlarge" | "r4.8xlarge" | "r4.large" | "r4.xlarge" | "r5.12xlarge" | "r5.16xlarge" | "r5.24xlarge" | "r5.2xlarge" | "r5.4xlarge" | "r5.8xlarge" | "r5.large" | "r5.xlarge" | "r5a.12xlarge" | "r5a.16xlarge" | "r5a.24xlarge" | "r5a.2xlarge" | "r5a.4xlarge" | "r5a.8xlarge" | "r5a.large" | "r5a.xlarge" | "t2.large" | "t2.medium" | "t2.micro" | "t2.small";
+export declare enum FleetType {
+    OnDemand = "ON_DEMAND",
+    Spot = "SPOT"
+}
+
+export interface LocationConfiguration {
+    
+    Location?: string;
+}
+export declare namespace LocationConfiguration {
+    
+    const filterSensitiveLog: (obj: LocationConfiguration) => any;
+}
+export declare enum ProtectionPolicy {
+    FullProtection = "FullProtection",
+    NoProtection = "NoProtection"
+}
+
+export interface ResourceCreationLimitPolicy {
+    
+    NewGameSessionsPerCreator?: number;
+    
+    PolicyPeriodInMinutes?: number;
+}
+export declare namespace ResourceCreationLimitPolicy {
+    
+    const filterSensitiveLog: (obj: ResourceCreationLimitPolicy) => any;
+}
+
+export interface ServerProcess {
+    
+    LaunchPath: string | undefined;
+    
+    Parameters?: string;
+    
+    ConcurrentExecutions: number | undefined;
+}
+export declare namespace ServerProcess {
+    
+    const filterSensitiveLog: (obj: ServerProcess) => any;
+}
+
+export interface RuntimeConfiguration {
+    
+    ServerProcesses?: ServerProcess[];
+    
+    MaxConcurrentGameSessionActivations?: number;
+    
+    GameSessionActivationTimeoutSeconds?: number;
+}
+export declare namespace RuntimeConfiguration {
+    
+    const filterSensitiveLog: (obj: RuntimeConfiguration) => any;
+}
+
+export interface CreateFleetInput {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    BuildId?: string;
+    
+    ScriptId?: string;
+    
+    ServerLaunchPath?: string;
+    
+    ServerLaunchParameters?: string;
+    
+    LogPaths?: string[];
+    
+    EC2InstanceType: EC2InstanceType | string | undefined;
+    
+    EC2InboundPermissions?: IpPermission[];
+    
+    NewGameSessionProtectionPolicy?: ProtectionPolicy | string;
+    
+    RuntimeConfiguration?: RuntimeConfiguration;
+    
+    ResourceCreationLimitPolicy?: ResourceCreationLimitPolicy;
+    
+    MetricGroups?: string[];
+    
+    PeerVpcAwsAccountId?: string;
+    
+    PeerVpcId?: string;
+    
+    FleetType?: FleetType | string;
+    
+    InstanceRoleArn?: string;
+    
+    CertificateConfiguration?: CertificateConfiguration;
+    
+    Locations?: LocationConfiguration[];
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateFleetInput {
+    
+    const filterSensitiveLog: (obj: CreateFleetInput) => any;
+}
+export declare enum FleetStatus {
+    ACTIVATING = "ACTIVATING",
+    ACTIVE = "ACTIVE",
+    BUILDING = "BUILDING",
+    DELETING = "DELETING",
+    DOWNLOADING = "DOWNLOADING",
+    ERROR = "ERROR",
+    NEW = "NEW",
+    TERMINATED = "TERMINATED",
+    VALIDATING = "VALIDATING"
+}
+export declare enum FleetAction {
+    AutoScaling = "AUTO_SCALING"
+}
+
+export interface FleetAttributes {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    FleetType?: FleetType | string;
+    
+    InstanceType?: EC2InstanceType | string;
+    
+    Description?: string;
+    
+    Name?: string;
+    
+    CreationTime?: Date;
+    
+    TerminationTime?: Date;
+    
+    Status?: FleetStatus | string;
+    
+    BuildId?: string;
+    
+    BuildArn?: string;
+    
+    ScriptId?: string;
+    
+    ScriptArn?: string;
+    
+    ServerLaunchPath?: string;
+    
+    ServerLaunchParameters?: string;
+    
+    LogPaths?: string[];
+    
+    NewGameSessionProtectionPolicy?: ProtectionPolicy | string;
+    
+    OperatingSystem?: OperatingSystem | string;
+    
+    ResourceCreationLimitPolicy?: ResourceCreationLimitPolicy;
+    
+    MetricGroups?: string[];
+    
+    StoppedActions?: (FleetAction | string)[];
+    
+    InstanceRoleArn?: string;
+    
+    CertificateConfiguration?: CertificateConfiguration;
+}
+export declare namespace FleetAttributes {
+    
+    const filterSensitiveLog: (obj: FleetAttributes) => any;
+}
+
+export interface LocationState {
+    
+    Location?: string;
+    
+    Status?: FleetStatus | string;
+}
+export declare namespace LocationState {
+    
+    const filterSensitiveLog: (obj: LocationState) => any;
+}
+
+export interface CreateFleetOutput {
+    
+    FleetAttributes?: FleetAttributes;
+    
+    LocationStates?: LocationState[];
+}
+export declare namespace CreateFleetOutput {
+    
+    const filterSensitiveLog: (obj: CreateFleetOutput) => any;
+}
+
+export interface CreateFleetLocationsInput {
+    
+    FleetId: string | undefined;
+    
+    Locations: LocationConfiguration[] | undefined;
+}
+export declare namespace CreateFleetLocationsInput {
+    
+    const filterSensitiveLog: (obj: CreateFleetLocationsInput) => any;
+}
+
+export interface CreateFleetLocationsOutput {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    LocationStates?: LocationState[];
+}
+export declare namespace CreateFleetLocationsOutput {
+    
+    const filterSensitiveLog: (obj: CreateFleetLocationsOutput) => any;
+}
+
+export interface InvalidFleetStatusException extends __SmithyException, $MetadataBearer {
+    name: "InvalidFleetStatusException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface TargetTrackingConfiguration {
+    
+    TargetValue: number | undefined;
+}
+export declare namespace TargetTrackingConfiguration {
+    
+    const filterSensitiveLog: (obj: TargetTrackingConfiguration) => any;
+}
+
+export interface GameServerGroupAutoScalingPolicy {
+    
+    EstimatedInstanceWarmup?: number;
+    
+    TargetTrackingConfiguration: TargetTrackingConfiguration | undefined;
+}
+export declare namespace GameServerGroupAutoScalingPolicy {
+    
+    const filterSensitiveLog: (obj: GameServerGroupAutoScalingPolicy) => any;
+}
+export declare enum GameServerProtectionPolicy {
+    FULL_PROTECTION = "FULL_PROTECTION",
+    NO_PROTECTION = "NO_PROTECTION"
+}
+export declare type GameServerGroupInstanceType = "c4.2xlarge" | "c4.4xlarge" | "c4.8xlarge" | "c4.large" | "c4.xlarge" | "c5.12xlarge" | "c5.18xlarge" | "c5.24xlarge" | "c5.2xlarge" | "c5.4xlarge" | "c5.9xlarge" | "c5.large" | "c5.xlarge" | "c5a.12xlarge" | "c5a.16xlarge" | "c5a.24xlarge" | "c5a.2xlarge" | "c5a.4xlarge" | "c5a.8xlarge" | "c5a.large" | "c5a.xlarge" | "c6g.12xlarge" | "c6g.16xlarge" | "c6g.2xlarge" | "c6g.4xlarge" | "c6g.8xlarge" | "c6g.large" | "c6g.medium" | "c6g.xlarge" | "m4.10xlarge" | "m4.2xlarge" | "m4.4xlarge" | "m4.large" | "m4.xlarge" | "m5.12xlarge" | "m5.16xlarge" | "m5.24xlarge" | "m5.2xlarge" | "m5.4xlarge" | "m5.8xlarge" | "m5.large" | "m5.xlarge" | "m5a.12xlarge" | "m5a.16xlarge" | "m5a.24xlarge" | "m5a.2xlarge" | "m5a.4xlarge" | "m5a.8xlarge" | "m5a.large" | "m5a.xlarge" | "m6g.12xlarge" | "m6g.16xlarge" | "m6g.2xlarge" | "m6g.4xlarge" | "m6g.8xlarge" | "m6g.large" | "m6g.medium" | "m6g.xlarge" | "r4.16xlarge" | "r4.2xlarge" | "r4.4xlarge" | "r4.8xlarge" | "r4.large" | "r4.xlarge" | "r5.12xlarge" | "r5.16xlarge" | "r5.24xlarge" | "r5.2xlarge" | "r5.4xlarge" | "r5.8xlarge" | "r5.large" | "r5.xlarge" | "r5a.12xlarge" | "r5a.16xlarge" | "r5a.24xlarge" | "r5a.2xlarge" | "r5a.4xlarge" | "r5a.8xlarge" | "r5a.large" | "r5a.xlarge" | "r6g.12xlarge" | "r6g.16xlarge" | "r6g.2xlarge" | "r6g.4xlarge" | "r6g.8xlarge" | "r6g.large" | "r6g.medium" | "r6g.xlarge";
+
+export interface InstanceDefinition {
+    
+    InstanceType: GameServerGroupInstanceType | string | undefined;
+    
+    WeightedCapacity?: string;
+}
+export declare namespace InstanceDefinition {
+    
+    const filterSensitiveLog: (obj: InstanceDefinition) => any;
+}
+
+export interface LaunchTemplateSpecification {
+    
+    LaunchTemplateId?: string;
+    
+    LaunchTemplateName?: string;
+    
+    Version?: string;
+}
+export declare namespace LaunchTemplateSpecification {
+    
+    const filterSensitiveLog: (obj: LaunchTemplateSpecification) => any;
+}
+export interface CreateGameServerGroupInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    RoleArn: string | undefined;
+    
+    MinSize: number | undefined;
+    
+    MaxSize: number | undefined;
+    
+    LaunchTemplate: LaunchTemplateSpecification | undefined;
+    
+    InstanceDefinitions: InstanceDefinition[] | undefined;
+    
+    AutoScalingPolicy?: GameServerGroupAutoScalingPolicy;
+    
+    BalancingStrategy?: BalancingStrategy | string;
+    
+    GameServerProtectionPolicy?: GameServerProtectionPolicy | string;
+    
+    VpcSubnets?: string[];
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateGameServerGroupInput {
+    
+    const filterSensitiveLog: (obj: CreateGameServerGroupInput) => any;
+}
+export declare enum GameServerGroupStatus {
+    ACTIVATING = "ACTIVATING",
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    DELETE_SCHEDULED = "DELETE_SCHEDULED",
+    DELETING = "DELETING",
+    ERROR = "ERROR",
+    NEW = "NEW"
+}
+export declare enum GameServerGroupAction {
+    REPLACE_INSTANCE_TYPES = "REPLACE_INSTANCE_TYPES"
+}
+
+export interface GameServerGroup {
+    
+    GameServerGroupName?: string;
+    
+    GameServerGroupArn?: string;
+    
+    RoleArn?: string;
+    
+    InstanceDefinitions?: InstanceDefinition[];
+    
+    BalancingStrategy?: BalancingStrategy | string;
+    
+    GameServerProtectionPolicy?: GameServerProtectionPolicy | string;
+    
+    AutoScalingGroupArn?: string;
+    
+    Status?: GameServerGroupStatus | string;
+    
+    StatusReason?: string;
+    
+    SuspendedActions?: (GameServerGroupAction | string)[];
+    
+    CreationTime?: Date;
+    
+    LastUpdatedTime?: Date;
+}
+export declare namespace GameServerGroup {
+    
+    const filterSensitiveLog: (obj: GameServerGroup) => any;
+}
+export interface CreateGameServerGroupOutput {
+    
+    GameServerGroup?: GameServerGroup;
+}
+export declare namespace CreateGameServerGroupOutput {
+    
+    const filterSensitiveLog: (obj: CreateGameServerGroupOutput) => any;
+}
+
+export interface GameProperty {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace GameProperty {
+    
+    const filterSensitiveLog: (obj: GameProperty) => any;
+}
+
+export interface CreateGameSessionInput {
+    
+    FleetId?: string;
+    
+    AliasId?: string;
+    
+    MaximumPlayerSessionCount: number | undefined;
+    
+    Name?: string;
+    
+    GameProperties?: GameProperty[];
+    
+    CreatorId?: string;
+    
+    GameSessionId?: string;
+    
+    IdempotencyToken?: string;
+    
+    GameSessionData?: string;
+    
+    Location?: string;
+}
+export declare namespace CreateGameSessionInput {
+    
+    const filterSensitiveLog: (obj: CreateGameSessionInput) => any;
+}
+export declare enum PlayerSessionCreationPolicy {
+    ACCEPT_ALL = "ACCEPT_ALL",
+    DENY_ALL = "DENY_ALL"
+}
+export declare enum GameSessionStatus {
+    ACTIVATING = "ACTIVATING",
+    ACTIVE = "ACTIVE",
+    ERROR = "ERROR",
+    TERMINATED = "TERMINATED",
+    TERMINATING = "TERMINATING"
+}
+export declare enum GameSessionStatusReason {
+    INTERRUPTED = "INTERRUPTED"
+}
+
+export interface GameSession {
+    
+    GameSessionId?: string;
+    
+    Name?: string;
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    CreationTime?: Date;
+    
+    TerminationTime?: Date;
+    
+    CurrentPlayerSessionCount?: number;
+    
+    MaximumPlayerSessionCount?: number;
+    
+    Status?: GameSessionStatus | string;
+    
+    StatusReason?: GameSessionStatusReason | string;
+    
+    GameProperties?: GameProperty[];
+    
+    IpAddress?: string;
+    
+    DnsName?: string;
+    
+    Port?: number;
+    
+    PlayerSessionCreationPolicy?: PlayerSessionCreationPolicy | string;
+    
+    CreatorId?: string;
+    
+    GameSessionData?: string;
+    
+    MatchmakerData?: string;
+    
+    Location?: string;
+}
+export declare namespace GameSession {
+    
+    const filterSensitiveLog: (obj: GameSession) => any;
+}
+
+export interface CreateGameSessionOutput {
+    
+    GameSession?: GameSession;
+}
+export declare namespace CreateGameSessionOutput {
+    
+    const filterSensitiveLog: (obj: CreateGameSessionOutput) => any;
+}
+
+export interface FleetCapacityExceededException extends __SmithyException, $MetadataBearer {
+    name: "FleetCapacityExceededException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface IdempotentParameterMismatchException extends __SmithyException, $MetadataBearer {
+    name: "IdempotentParameterMismatchException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface TerminalRoutingStrategyException extends __SmithyException, $MetadataBearer {
+    name: "TerminalRoutingStrategyException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface GameSessionQueueDestination {
+    
+    DestinationArn?: string;
+}
+export declare namespace GameSessionQueueDestination {
+    
+    const filterSensitiveLog: (obj: GameSessionQueueDestination) => any;
+}
+
+export interface FilterConfiguration {
+    
+    AllowedLocations?: string[];
+}
+export declare namespace FilterConfiguration {
+    
+    const filterSensitiveLog: (obj: FilterConfiguration) => any;
+}
+
+export interface PlayerLatencyPolicy {
+    
+    MaximumIndividualPlayerLatencyMilliseconds?: number;
+    
+    PolicyDurationSeconds?: number;
+}
+export declare namespace PlayerLatencyPolicy {
+    
+    const filterSensitiveLog: (obj: PlayerLatencyPolicy) => any;
+}
+export declare enum PriorityType {
+    COST = "COST",
+    DESTINATION = "DESTINATION",
+    LATENCY = "LATENCY",
+    LOCATION = "LOCATION"
+}
+
+export interface PriorityConfiguration {
+    
+    PriorityOrder?: (PriorityType | string)[];
+    
+    LocationOrder?: string[];
+}
+export declare namespace PriorityConfiguration {
+    
+    const filterSensitiveLog: (obj: PriorityConfiguration) => any;
+}
+
+export interface CreateGameSessionQueueInput {
+    
+    Name: string | undefined;
+    
+    TimeoutInSeconds?: number;
+    
+    PlayerLatencyPolicies?: PlayerLatencyPolicy[];
+    
+    Destinations?: GameSessionQueueDestination[];
+    
+    FilterConfiguration?: FilterConfiguration;
+    
+    PriorityConfiguration?: PriorityConfiguration;
+    
+    CustomEventData?: string;
+    
+    NotificationTarget?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateGameSessionQueueInput {
+    
+    const filterSensitiveLog: (obj: CreateGameSessionQueueInput) => any;
+}
+
+export interface GameSessionQueue {
+    
+    Name?: string;
+    
+    GameSessionQueueArn?: string;
+    
+    TimeoutInSeconds?: number;
+    
+    PlayerLatencyPolicies?: PlayerLatencyPolicy[];
+    
+    Destinations?: GameSessionQueueDestination[];
+    
+    FilterConfiguration?: FilterConfiguration;
+    
+    PriorityConfiguration?: PriorityConfiguration;
+    
+    CustomEventData?: string;
+    
+    NotificationTarget?: string;
+}
+export declare namespace GameSessionQueue {
+    
+    const filterSensitiveLog: (obj: GameSessionQueue) => any;
+}
+
+export interface CreateGameSessionQueueOutput {
+    
+    GameSessionQueue?: GameSessionQueue;
+}
+export declare namespace CreateGameSessionQueueOutput {
+    
+    const filterSensitiveLog: (obj: CreateGameSessionQueueOutput) => any;
+}
+export declare enum FlexMatchMode {
+    STANDALONE = "STANDALONE",
+    WITH_QUEUE = "WITH_QUEUE"
+}
+
+export interface CreateMatchmakingConfigurationInput {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    GameSessionQueueArns?: string[];
+    
+    RequestTimeoutSeconds: number | undefined;
+    
+    AcceptanceTimeoutSeconds?: number;
+    
+    AcceptanceRequired: boolean | undefined;
+    
+    RuleSetName: string | undefined;
+    
+    NotificationTarget?: string;
+    
+    AdditionalPlayerCount?: number;
+    
+    CustomEventData?: string;
+    
+    GameProperties?: GameProperty[];
+    
+    GameSessionData?: string;
+    
+    BackfillMode?: BackfillMode | string;
+    
+    FlexMatchMode?: FlexMatchMode | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateMatchmakingConfigurationInput {
+    
+    const filterSensitiveLog: (obj: CreateMatchmakingConfigurationInput) => any;
+}
+
+export interface MatchmakingConfiguration {
+    
+    Name?: string;
+    
+    ConfigurationArn?: string;
+    
+    Description?: string;
+    
+    GameSessionQueueArns?: string[];
+    
+    RequestTimeoutSeconds?: number;
+    
+    AcceptanceTimeoutSeconds?: number;
+    
+    AcceptanceRequired?: boolean;
+    
+    RuleSetName?: string;
+    
+    RuleSetArn?: string;
+    
+    NotificationTarget?: string;
+    
+    AdditionalPlayerCount?: number;
+    
+    CustomEventData?: string;
+    
+    CreationTime?: Date;
+    
+    GameProperties?: GameProperty[];
+    
+    GameSessionData?: string;
+    
+    BackfillMode?: BackfillMode | string;
+    
+    FlexMatchMode?: FlexMatchMode | string;
+}
+export declare namespace MatchmakingConfiguration {
+    
+    const filterSensitiveLog: (obj: MatchmakingConfiguration) => any;
+}
+
+export interface CreateMatchmakingConfigurationOutput {
+    
+    Configuration?: MatchmakingConfiguration;
+}
+export declare namespace CreateMatchmakingConfigurationOutput {
+    
+    const filterSensitiveLog: (obj: CreateMatchmakingConfigurationOutput) => any;
+}
+
+export interface CreateMatchmakingRuleSetInput {
+    
+    Name: string | undefined;
+    
+    RuleSetBody: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateMatchmakingRuleSetInput {
+    
+    const filterSensitiveLog: (obj: CreateMatchmakingRuleSetInput) => any;
+}
+
+export interface MatchmakingRuleSet {
+    
+    RuleSetName?: string;
+    
+    RuleSetArn?: string;
+    
+    RuleSetBody: string | undefined;
+    
+    CreationTime?: Date;
+}
+export declare namespace MatchmakingRuleSet {
+    
+    const filterSensitiveLog: (obj: MatchmakingRuleSet) => any;
+}
+
+export interface CreateMatchmakingRuleSetOutput {
+    
+    RuleSet: MatchmakingRuleSet | undefined;
+}
+export declare namespace CreateMatchmakingRuleSetOutput {
+    
+    const filterSensitiveLog: (obj: CreateMatchmakingRuleSetOutput) => any;
+}
+
+export interface CreatePlayerSessionInput {
+    
+    GameSessionId: string | undefined;
+    
+    PlayerId: string | undefined;
+    
+    PlayerData?: string;
+}
+export declare namespace CreatePlayerSessionInput {
+    
+    const filterSensitiveLog: (obj: CreatePlayerSessionInput) => any;
+}
+export declare enum PlayerSessionStatus {
+    ACTIVE = "ACTIVE",
+    COMPLETED = "COMPLETED",
+    RESERVED = "RESERVED",
+    TIMEDOUT = "TIMEDOUT"
+}
+
+export interface PlayerSession {
+    
+    PlayerSessionId?: string;
+    
+    PlayerId?: string;
+    
+    GameSessionId?: string;
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    CreationTime?: Date;
+    
+    TerminationTime?: Date;
+    
+    Status?: PlayerSessionStatus | string;
+    
+    IpAddress?: string;
+    
+    DnsName?: string;
+    
+    Port?: number;
+    
+    PlayerData?: string;
+}
+export declare namespace PlayerSession {
+    
+    const filterSensitiveLog: (obj: PlayerSession) => any;
+}
+
+export interface CreatePlayerSessionOutput {
+    
+    PlayerSession?: PlayerSession;
+}
+export declare namespace CreatePlayerSessionOutput {
+    
+    const filterSensitiveLog: (obj: CreatePlayerSessionOutput) => any;
+}
+
+export interface GameSessionFullException extends __SmithyException, $MetadataBearer {
+    name: "GameSessionFullException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface InvalidGameSessionStatusException extends __SmithyException, $MetadataBearer {
+    name: "InvalidGameSessionStatusException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface CreatePlayerSessionsInput {
+    
+    GameSessionId: string | undefined;
+    
+    PlayerIds: string[] | undefined;
+    
+    PlayerDataMap?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreatePlayerSessionsInput {
+    
+    const filterSensitiveLog: (obj: CreatePlayerSessionsInput) => any;
+}
+
+export interface CreatePlayerSessionsOutput {
+    
+    PlayerSessions?: PlayerSession[];
+}
+export declare namespace CreatePlayerSessionsOutput {
+    
+    const filterSensitiveLog: (obj: CreatePlayerSessionsOutput) => any;
+}
+export interface CreateScriptInput {
+    
+    Name?: string;
+    
+    Version?: string;
+    
+    StorageLocation?: S3Location;
+    
+    ZipFile?: Uint8Array;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateScriptInput {
+    
+    const filterSensitiveLog: (obj: CreateScriptInput) => any;
+}
+
+export interface Script {
+    
+    ScriptId?: string;
+    
+    ScriptArn?: string;
+    
+    Name?: string;
+    
+    Version?: string;
+    
+    SizeOnDisk?: number;
+    
+    CreationTime?: Date;
+    
+    StorageLocation?: S3Location;
+}
+export declare namespace Script {
+    
+    const filterSensitiveLog: (obj: Script) => any;
+}
+export interface CreateScriptOutput {
+    
+    Script?: Script;
+}
+export declare namespace CreateScriptOutput {
+    
+    const filterSensitiveLog: (obj: CreateScriptOutput) => any;
+}
+
+export interface CreateVpcPeeringAuthorizationInput {
+    
+    GameLiftAwsAccountId: string | undefined;
+    
+    PeerVpcId: string | undefined;
+}
+export declare namespace CreateVpcPeeringAuthorizationInput {
+    
+    const filterSensitiveLog: (obj: CreateVpcPeeringAuthorizationInput) => any;
+}
+
+export interface VpcPeeringAuthorization {
+    
+    GameLiftAwsAccountId?: string;
+    
+    PeerVpcAwsAccountId?: string;
+    
+    PeerVpcId?: string;
+    
+    CreationTime?: Date;
+    
+    ExpirationTime?: Date;
+}
+export declare namespace VpcPeeringAuthorization {
+    
+    const filterSensitiveLog: (obj: VpcPeeringAuthorization) => any;
+}
+
+export interface CreateVpcPeeringAuthorizationOutput {
+    
+    VpcPeeringAuthorization?: VpcPeeringAuthorization;
+}
+export declare namespace CreateVpcPeeringAuthorizationOutput {
+    
+    const filterSensitiveLog: (obj: CreateVpcPeeringAuthorizationOutput) => any;
+}
+
+export interface CreateVpcPeeringConnectionInput {
+    
+    FleetId: string | undefined;
+    
+    PeerVpcAwsAccountId: string | undefined;
+    
+    PeerVpcId: string | undefined;
+}
+export declare namespace CreateVpcPeeringConnectionInput {
+    
+    const filterSensitiveLog: (obj: CreateVpcPeeringConnectionInput) => any;
+}
+export interface CreateVpcPeeringConnectionOutput {
+}
+export declare namespace CreateVpcPeeringConnectionOutput {
+    
+    const filterSensitiveLog: (obj: CreateVpcPeeringConnectionOutput) => any;
+}
+
+export interface DeleteAliasInput {
+    
+    AliasId: string | undefined;
+}
+export declare namespace DeleteAliasInput {
+    
+    const filterSensitiveLog: (obj: DeleteAliasInput) => any;
+}
+
+export interface DeleteBuildInput {
+    
+    BuildId: string | undefined;
+}
+export declare namespace DeleteBuildInput {
+    
+    const filterSensitiveLog: (obj: DeleteBuildInput) => any;
+}
+
+export interface DeleteFleetInput {
+    
+    FleetId: string | undefined;
+}
+export declare namespace DeleteFleetInput {
+    
+    const filterSensitiveLog: (obj: DeleteFleetInput) => any;
+}
+
+export interface DeleteFleetLocationsInput {
+    
+    FleetId: string | undefined;
+    
+    Locations: string[] | undefined;
+}
+export declare namespace DeleteFleetLocationsInput {
+    
+    const filterSensitiveLog: (obj: DeleteFleetLocationsInput) => any;
+}
+
+export interface DeleteFleetLocationsOutput {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    LocationStates?: LocationState[];
+}
+export declare namespace DeleteFleetLocationsOutput {
+    
+    const filterSensitiveLog: (obj: DeleteFleetLocationsOutput) => any;
+}
+export declare enum GameServerGroupDeleteOption {
+    FORCE_DELETE = "FORCE_DELETE",
+    RETAIN = "RETAIN",
+    SAFE_DELETE = "SAFE_DELETE"
+}
+export interface DeleteGameServerGroupInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    DeleteOption?: GameServerGroupDeleteOption | string;
+}
+export declare namespace DeleteGameServerGroupInput {
+    
+    const filterSensitiveLog: (obj: DeleteGameServerGroupInput) => any;
+}
+export interface DeleteGameServerGroupOutput {
+    
+    GameServerGroup?: GameServerGroup;
+}
+export declare namespace DeleteGameServerGroupOutput {
+    
+    const filterSensitiveLog: (obj: DeleteGameServerGroupOutput) => any;
+}
+
+export interface DeleteGameSessionQueueInput {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteGameSessionQueueInput {
+    
+    const filterSensitiveLog: (obj: DeleteGameSessionQueueInput) => any;
+}
+export interface DeleteGameSessionQueueOutput {
+}
+export declare namespace DeleteGameSessionQueueOutput {
+    
+    const filterSensitiveLog: (obj: DeleteGameSessionQueueOutput) => any;
+}
+
+export interface DeleteMatchmakingConfigurationInput {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteMatchmakingConfigurationInput {
+    
+    const filterSensitiveLog: (obj: DeleteMatchmakingConfigurationInput) => any;
+}
+export interface DeleteMatchmakingConfigurationOutput {
+}
+export declare namespace DeleteMatchmakingConfigurationOutput {
+    
+    const filterSensitiveLog: (obj: DeleteMatchmakingConfigurationOutput) => any;
+}
+
+export interface DeleteMatchmakingRuleSetInput {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteMatchmakingRuleSetInput {
+    
+    const filterSensitiveLog: (obj: DeleteMatchmakingRuleSetInput) => any;
+}
+
+export interface DeleteMatchmakingRuleSetOutput {
+}
+export declare namespace DeleteMatchmakingRuleSetOutput {
+    
+    const filterSensitiveLog: (obj: DeleteMatchmakingRuleSetOutput) => any;
+}
+
+export interface DeleteScalingPolicyInput {
+    
+    Name: string | undefined;
+    
+    FleetId: string | undefined;
+}
+export declare namespace DeleteScalingPolicyInput {
+    
+    const filterSensitiveLog: (obj: DeleteScalingPolicyInput) => any;
+}
+export interface DeleteScriptInput {
+    
+    ScriptId: string | undefined;
+}
+export declare namespace DeleteScriptInput {
+    
+    const filterSensitiveLog: (obj: DeleteScriptInput) => any;
+}
+
+export interface DeleteVpcPeeringAuthorizationInput {
+    
+    GameLiftAwsAccountId: string | undefined;
+    
+    PeerVpcId: string | undefined;
+}
+export declare namespace DeleteVpcPeeringAuthorizationInput {
+    
+    const filterSensitiveLog: (obj: DeleteVpcPeeringAuthorizationInput) => any;
+}
+export interface DeleteVpcPeeringAuthorizationOutput {
+}
+export declare namespace DeleteVpcPeeringAuthorizationOutput {
+    
+    const filterSensitiveLog: (obj: DeleteVpcPeeringAuthorizationOutput) => any;
+}
+
+export interface DeleteVpcPeeringConnectionInput {
+    
+    FleetId: string | undefined;
+    
+    VpcPeeringConnectionId: string | undefined;
+}
+export declare namespace DeleteVpcPeeringConnectionInput {
+    
+    const filterSensitiveLog: (obj: DeleteVpcPeeringConnectionInput) => any;
+}
+export interface DeleteVpcPeeringConnectionOutput {
+}
+export declare namespace DeleteVpcPeeringConnectionOutput {
+    
+    const filterSensitiveLog: (obj: DeleteVpcPeeringConnectionOutput) => any;
+}
+export interface DeregisterGameServerInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    GameServerId: string | undefined;
+}
+export declare namespace DeregisterGameServerInput {
+    
+    const filterSensitiveLog: (obj: DeregisterGameServerInput) => any;
+}
+
+export interface DescribeAliasInput {
+    
+    AliasId: string | undefined;
+}
+export declare namespace DescribeAliasInput {
+    
+    const filterSensitiveLog: (obj: DescribeAliasInput) => any;
+}
+
+export interface DescribeAliasOutput {
+    
+    Alias?: Alias;
+}
+export declare namespace DescribeAliasOutput {
+    
+    const filterSensitiveLog: (obj: DescribeAliasOutput) => any;
+}
+
+export interface DescribeBuildInput {
+    
+    BuildId: string | undefined;
+}
+export declare namespace DescribeBuildInput {
+    
+    const filterSensitiveLog: (obj: DescribeBuildInput) => any;
+}
+
+export interface DescribeBuildOutput {
+    
+    Build?: Build;
+}
+export declare namespace DescribeBuildOutput {
+    
+    const filterSensitiveLog: (obj: DescribeBuildOutput) => any;
+}
+
+export interface DescribeEC2InstanceLimitsInput {
+    
+    EC2InstanceType?: EC2InstanceType | string;
+    
+    Location?: string;
+}
+export declare namespace DescribeEC2InstanceLimitsInput {
+    
+    const filterSensitiveLog: (obj: DescribeEC2InstanceLimitsInput) => any;
+}
+
+export interface EC2InstanceLimit {
+    
+    EC2InstanceType?: EC2InstanceType | string;
+    
+    CurrentInstances?: number;
+    
+    InstanceLimit?: number;
+    
+    Location?: string;
+}
+export declare namespace EC2InstanceLimit {
+    
+    const filterSensitiveLog: (obj: EC2InstanceLimit) => any;
+}
+
+export interface DescribeEC2InstanceLimitsOutput {
+    
+    EC2InstanceLimits?: EC2InstanceLimit[];
+}
+export declare namespace DescribeEC2InstanceLimitsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeEC2InstanceLimitsOutput) => any;
+}
+
+export interface DescribeFleetAttributesInput {
+    
+    FleetIds?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetAttributesInput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetAttributesInput) => any;
+}
+
+export interface DescribeFleetAttributesOutput {
+    
+    FleetAttributes?: FleetAttributes[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetAttributesOutput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetAttributesOutput) => any;
+}
+
+export interface DescribeFleetCapacityInput {
+    
+    FleetIds?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetCapacityInput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetCapacityInput) => any;
+}
+
+export interface EC2InstanceCounts {
+    
+    DESIRED?: number;
+    
+    MINIMUM?: number;
+    
+    MAXIMUM?: number;
+    
+    PENDING?: number;
+    
+    ACTIVE?: number;
+    
+    IDLE?: number;
+    
+    TERMINATING?: number;
+}
+export declare namespace EC2InstanceCounts {
+    
+    const filterSensitiveLog: (obj: EC2InstanceCounts) => any;
+}
+
+export interface FleetCapacity {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    InstanceType?: EC2InstanceType | string;
+    
+    InstanceCounts?: EC2InstanceCounts;
+    
+    Location?: string;
+}
+export declare namespace FleetCapacity {
+    
+    const filterSensitiveLog: (obj: FleetCapacity) => any;
+}
+
+export interface DescribeFleetCapacityOutput {
+    
+    FleetCapacity?: FleetCapacity[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetCapacityOutput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetCapacityOutput) => any;
+}
+
+export interface DescribeFleetEventsInput {
+    
+    FleetId: string | undefined;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetEventsInput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetEventsInput) => any;
+}
+export declare enum EventCode {
+    FLEET_ACTIVATION_FAILED = "FLEET_ACTIVATION_FAILED",
+    FLEET_ACTIVATION_FAILED_NO_INSTANCES = "FLEET_ACTIVATION_FAILED_NO_INSTANCES",
+    FLEET_BINARY_DOWNLOAD_FAILED = "FLEET_BINARY_DOWNLOAD_FAILED",
+    FLEET_CREATED = "FLEET_CREATED",
+    FLEET_CREATION_EXTRACTING_BUILD = "FLEET_CREATION_EXTRACTING_BUILD",
+    FLEET_CREATION_RUNNING_INSTALLER = "FLEET_CREATION_RUNNING_INSTALLER",
+    FLEET_CREATION_VALIDATING_RUNTIME_CONFIG = "FLEET_CREATION_VALIDATING_RUNTIME_CONFIG",
+    FLEET_DELETED = "FLEET_DELETED",
+    FLEET_INITIALIZATION_FAILED = "FLEET_INITIALIZATION_FAILED",
+    FLEET_NEW_GAME_SESSION_PROTECTION_POLICY_UPDATED = "FLEET_NEW_GAME_SESSION_PROTECTION_POLICY_UPDATED",
+    FLEET_SCALING_EVENT = "FLEET_SCALING_EVENT",
+    FLEET_STATE_ACTIVATING = "FLEET_STATE_ACTIVATING",
+    FLEET_STATE_ACTIVE = "FLEET_STATE_ACTIVE",
+    FLEET_STATE_BUILDING = "FLEET_STATE_BUILDING",
+    FLEET_STATE_DOWNLOADING = "FLEET_STATE_DOWNLOADING",
+    FLEET_STATE_ERROR = "FLEET_STATE_ERROR",
+    FLEET_STATE_VALIDATING = "FLEET_STATE_VALIDATING",
+    FLEET_VALIDATION_EXECUTABLE_RUNTIME_FAILURE = "FLEET_VALIDATION_EXECUTABLE_RUNTIME_FAILURE",
+    FLEET_VALIDATION_LAUNCH_PATH_NOT_FOUND = "FLEET_VALIDATION_LAUNCH_PATH_NOT_FOUND",
+    FLEET_VALIDATION_TIMED_OUT = "FLEET_VALIDATION_TIMED_OUT",
+    FLEET_VPC_PEERING_DELETED = "FLEET_VPC_PEERING_DELETED",
+    FLEET_VPC_PEERING_FAILED = "FLEET_VPC_PEERING_FAILED",
+    FLEET_VPC_PEERING_SUCCEEDED = "FLEET_VPC_PEERING_SUCCEEDED",
+    GAME_SESSION_ACTIVATION_TIMEOUT = "GAME_SESSION_ACTIVATION_TIMEOUT",
+    GENERIC_EVENT = "GENERIC_EVENT",
+    INSTANCE_INTERRUPTED = "INSTANCE_INTERRUPTED",
+    SERVER_PROCESS_CRASHED = "SERVER_PROCESS_CRASHED",
+    SERVER_PROCESS_FORCE_TERMINATED = "SERVER_PROCESS_FORCE_TERMINATED",
+    SERVER_PROCESS_INVALID_PATH = "SERVER_PROCESS_INVALID_PATH",
+    SERVER_PROCESS_PROCESS_EXIT_TIMEOUT = "SERVER_PROCESS_PROCESS_EXIT_TIMEOUT",
+    SERVER_PROCESS_PROCESS_READY_TIMEOUT = "SERVER_PROCESS_PROCESS_READY_TIMEOUT",
+    SERVER_PROCESS_SDK_INITIALIZATION_TIMEOUT = "SERVER_PROCESS_SDK_INITIALIZATION_TIMEOUT",
+    SERVER_PROCESS_TERMINATED_UNHEALTHY = "SERVER_PROCESS_TERMINATED_UNHEALTHY"
+}
+
+export interface Event {
+    
+    EventId?: string;
+    
+    ResourceId?: string;
+    
+    EventCode?: EventCode | string;
+    
+    Message?: string;
+    
+    EventTime?: Date;
+    
+    PreSignedLogUrl?: string;
+}
+export declare namespace Event {
+    
+    const filterSensitiveLog: (obj: Event) => any;
+}
+
+export interface DescribeFleetEventsOutput {
+    
+    Events?: Event[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetEventsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetEventsOutput) => any;
+}
+
+export interface DescribeFleetLocationAttributesInput {
+    
+    FleetId: string | undefined;
+    
+    Locations?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetLocationAttributesInput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetLocationAttributesInput) => any;
+}
+export declare enum LocationUpdateStatus {
+    PENDING_UPDATE = "PENDING_UPDATE"
+}
+
+export interface LocationAttributes {
+    
+    LocationState?: LocationState;
+    
+    StoppedActions?: (FleetAction | string)[];
+    
+    UpdateStatus?: LocationUpdateStatus | string;
+}
+export declare namespace LocationAttributes {
+    
+    const filterSensitiveLog: (obj: LocationAttributes) => any;
+}
+
+export interface DescribeFleetLocationAttributesOutput {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    LocationAttributes?: LocationAttributes[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetLocationAttributesOutput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetLocationAttributesOutput) => any;
+}
+
+export interface DescribeFleetLocationCapacityInput {
+    
+    FleetId: string | undefined;
+    
+    Location: string | undefined;
+}
+export declare namespace DescribeFleetLocationCapacityInput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetLocationCapacityInput) => any;
+}
+
+export interface DescribeFleetLocationCapacityOutput {
+    
+    FleetCapacity?: FleetCapacity;
+}
+export declare namespace DescribeFleetLocationCapacityOutput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetLocationCapacityOutput) => any;
+}
+
+export interface DescribeFleetLocationUtilizationInput {
+    
+    FleetId: string | undefined;
+    
+    Location: string | undefined;
+}
+export declare namespace DescribeFleetLocationUtilizationInput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetLocationUtilizationInput) => any;
+}
+
+export interface FleetUtilization {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    ActiveServerProcessCount?: number;
+    
+    ActiveGameSessionCount?: number;
+    
+    CurrentPlayerSessionCount?: number;
+    
+    MaximumPlayerSessionCount?: number;
+    
+    Location?: string;
+}
+export declare namespace FleetUtilization {
+    
+    const filterSensitiveLog: (obj: FleetUtilization) => any;
+}
+
+export interface DescribeFleetLocationUtilizationOutput {
+    
+    FleetUtilization?: FleetUtilization;
+}
+export declare namespace DescribeFleetLocationUtilizationOutput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetLocationUtilizationOutput) => any;
+}
+
+export interface DescribeFleetPortSettingsInput {
+    
+    FleetId: string | undefined;
+    
+    Location?: string;
+}
+export declare namespace DescribeFleetPortSettingsInput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetPortSettingsInput) => any;
+}
+
+export interface DescribeFleetPortSettingsOutput {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    InboundPermissions?: IpPermission[];
+    
+    UpdateStatus?: LocationUpdateStatus | string;
+    
+    Location?: string;
+}
+export declare namespace DescribeFleetPortSettingsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetPortSettingsOutput) => any;
+}
+
+export interface DescribeFleetUtilizationInput {
+    
+    FleetIds?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetUtilizationInput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetUtilizationInput) => any;
+}
+
+export interface DescribeFleetUtilizationOutput {
+    
+    FleetUtilization?: FleetUtilization[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetUtilizationOutput {
+    
+    const filterSensitiveLog: (obj: DescribeFleetUtilizationOutput) => any;
+}
+export interface DescribeGameServerInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    GameServerId: string | undefined;
+}
+export declare namespace DescribeGameServerInput {
+    
+    const filterSensitiveLog: (obj: DescribeGameServerInput) => any;
+}
+export interface DescribeGameServerOutput {
+    
+    GameServer?: GameServer;
+}
+export declare namespace DescribeGameServerOutput {
+    
+    const filterSensitiveLog: (obj: DescribeGameServerOutput) => any;
+}
+export interface DescribeGameServerGroupInput {
+    
+    GameServerGroupName: string | undefined;
+}
+export declare namespace DescribeGameServerGroupInput {
+    
+    const filterSensitiveLog: (obj: DescribeGameServerGroupInput) => any;
+}
+export interface DescribeGameServerGroupOutput {
+    
+    GameServerGroup?: GameServerGroup;
+}
+export declare namespace DescribeGameServerGroupOutput {
+    
+    const filterSensitiveLog: (obj: DescribeGameServerGroupOutput) => any;
+}
+export interface DescribeGameServerInstancesInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    InstanceIds?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeGameServerInstancesInput {
+    
+    const filterSensitiveLog: (obj: DescribeGameServerInstancesInput) => any;
+}
+export declare enum GameServerInstanceStatus {
+    ACTIVE = "ACTIVE",
+    DRAINING = "DRAINING",
+    SPOT_TERMINATING = "SPOT_TERMINATING"
+}
+
+export interface GameServerInstance {
+    
+    GameServerGroupName?: string;
+    
+    GameServerGroupArn?: string;
+    
+    InstanceId?: string;
+    
+    InstanceStatus?: GameServerInstanceStatus | string;
+}
+export declare namespace GameServerInstance {
+    
+    const filterSensitiveLog: (obj: GameServerInstance) => any;
+}
+export interface DescribeGameServerInstancesOutput {
+    
+    GameServerInstances?: GameServerInstance[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeGameServerInstancesOutput {
+    
+    const filterSensitiveLog: (obj: DescribeGameServerInstancesOutput) => any;
+}
+
+export interface DescribeGameSessionDetailsInput {
+    
+    FleetId?: string;
+    
+    GameSessionId?: string;
+    
+    AliasId?: string;
+    
+    Location?: string;
+    
+    StatusFilter?: string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeGameSessionDetailsInput {
+    
+    const filterSensitiveLog: (obj: DescribeGameSessionDetailsInput) => any;
+}
+
+export interface GameSessionDetail {
+    
+    GameSession?: GameSession;
+    
+    ProtectionPolicy?: ProtectionPolicy | string;
+}
+export declare namespace GameSessionDetail {
+    
+    const filterSensitiveLog: (obj: GameSessionDetail) => any;
+}
+
+export interface DescribeGameSessionDetailsOutput {
+    
+    GameSessionDetails?: GameSessionDetail[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeGameSessionDetailsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeGameSessionDetailsOutput) => any;
+}
+
+export interface DescribeGameSessionPlacementInput {
+    
+    PlacementId: string | undefined;
+}
+export declare namespace DescribeGameSessionPlacementInput {
+    
+    const filterSensitiveLog: (obj: DescribeGameSessionPlacementInput) => any;
+}
+
+export interface PlacedPlayerSession {
+    
+    PlayerId?: string;
+    
+    PlayerSessionId?: string;
+}
+export declare namespace PlacedPlayerSession {
+    
+    const filterSensitiveLog: (obj: PlacedPlayerSession) => any;
+}
+
+export interface PlayerLatency {
+    
+    PlayerId?: string;
+    
+    RegionIdentifier?: string;
+    
+    LatencyInMilliseconds?: number;
+}
+export declare namespace PlayerLatency {
+    
+    const filterSensitiveLog: (obj: PlayerLatency) => any;
+}
+export declare enum GameSessionPlacementState {
+    CANCELLED = "CANCELLED",
+    FAILED = "FAILED",
+    FULFILLED = "FULFILLED",
+    PENDING = "PENDING",
+    TIMED_OUT = "TIMED_OUT"
+}
+
+export interface GameSessionPlacement {
+    
+    PlacementId?: string;
+    
+    GameSessionQueueName?: string;
+    
+    Status?: GameSessionPlacementState | string;
+    
+    GameProperties?: GameProperty[];
+    
+    MaximumPlayerSessionCount?: number;
+    
+    GameSessionName?: string;
+    
+    GameSessionId?: string;
+    
+    GameSessionArn?: string;
+    
+    GameSessionRegion?: string;
+    
+    PlayerLatencies?: PlayerLatency[];
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    IpAddress?: string;
+    
+    DnsName?: string;
+    
+    Port?: number;
+    
+    PlacedPlayerSessions?: PlacedPlayerSession[];
+    
+    GameSessionData?: string;
+    
+    MatchmakerData?: string;
+}
+export declare namespace GameSessionPlacement {
+    
+    const filterSensitiveLog: (obj: GameSessionPlacement) => any;
+}
+
+export interface DescribeGameSessionPlacementOutput {
+    
+    GameSessionPlacement?: GameSessionPlacement;
+}
+export declare namespace DescribeGameSessionPlacementOutput {
+    
+    const filterSensitiveLog: (obj: DescribeGameSessionPlacementOutput) => any;
+}
+
+export interface DescribeGameSessionQueuesInput {
+    
+    Names?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeGameSessionQueuesInput {
+    
+    const filterSensitiveLog: (obj: DescribeGameSessionQueuesInput) => any;
+}
+
+export interface DescribeGameSessionQueuesOutput {
+    
+    GameSessionQueues?: GameSessionQueue[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeGameSessionQueuesOutput {
+    
+    const filterSensitiveLog: (obj: DescribeGameSessionQueuesOutput) => any;
+}
+
+export interface DescribeGameSessionsInput {
+    
+    FleetId?: string;
+    
+    GameSessionId?: string;
+    
+    AliasId?: string;
+    
+    Location?: string;
+    
+    StatusFilter?: string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeGameSessionsInput {
+    
+    const filterSensitiveLog: (obj: DescribeGameSessionsInput) => any;
+}
+
+export interface DescribeGameSessionsOutput {
+    
+    GameSessions?: GameSession[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeGameSessionsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeGameSessionsOutput) => any;
+}
+
+export interface DescribeInstancesInput {
+    
+    FleetId: string | undefined;
+    
+    InstanceId?: string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+    
+    Location?: string;
+}
+export declare namespace DescribeInstancesInput {
+    
+    const filterSensitiveLog: (obj: DescribeInstancesInput) => any;
+}
+export declare enum InstanceStatus {
+    ACTIVE = "ACTIVE",
+    PENDING = "PENDING",
+    TERMINATING = "TERMINATING"
+}
+
+export interface Instance {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    InstanceId?: string;
+    
+    IpAddress?: string;
+    
+    DnsName?: string;
+    
+    OperatingSystem?: OperatingSystem | string;
+    
+    Type?: EC2InstanceType | string;
+    
+    Status?: InstanceStatus | string;
+    
+    CreationTime?: Date;
+    
+    Location?: string;
+}
+export declare namespace Instance {
+    
+    const filterSensitiveLog: (obj: Instance) => any;
+}
+
+export interface DescribeInstancesOutput {
+    
+    Instances?: Instance[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeInstancesOutput {
+    
+    const filterSensitiveLog: (obj: DescribeInstancesOutput) => any;
+}
+
+export interface DescribeMatchmakingInput {
+    
+    TicketIds: string[] | undefined;
+}
+export declare namespace DescribeMatchmakingInput {
+    
+    const filterSensitiveLog: (obj: DescribeMatchmakingInput) => any;
+}
+
+export interface MatchedPlayerSession {
+    
+    PlayerId?: string;
+    
+    PlayerSessionId?: string;
+}
+export declare namespace MatchedPlayerSession {
+    
+    const filterSensitiveLog: (obj: MatchedPlayerSession) => any;
+}
+
+export interface GameSessionConnectionInfo {
+    
+    GameSessionArn?: string;
+    
+    IpAddress?: string;
+    
+    DnsName?: string;
+    
+    Port?: number;
+    
+    MatchedPlayerSessions?: MatchedPlayerSession[];
+}
+export declare namespace GameSessionConnectionInfo {
+    
+    const filterSensitiveLog: (obj: GameSessionConnectionInfo) => any;
+}
+
+export interface Player {
+    
+    PlayerId?: string;
+    
+    PlayerAttributes?: {
+        [key: string]: AttributeValue;
+    };
+    
+    Team?: string;
+    
+    LatencyInMs?: {
+        [key: string]: number;
+    };
+}
+export declare namespace Player {
+    
+    const filterSensitiveLog: (obj: Player) => any;
+}
+export declare type MatchmakingConfigurationStatus = "CANCELLED" | "COMPLETED" | "FAILED" | "PLACING" | "QUEUED" | "REQUIRES_ACCEPTANCE" | "SEARCHING" | "TIMED_OUT";
+
+export interface MatchmakingTicket {
+    
+    TicketId?: string;
+    
+    ConfigurationName?: string;
+    
+    ConfigurationArn?: string;
+    
+    Status?: MatchmakingConfigurationStatus | string;
+    
+    StatusReason?: string;
+    
+    StatusMessage?: string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    Players?: Player[];
+    
+    GameSessionConnectionInfo?: GameSessionConnectionInfo;
+    
+    EstimatedWaitTime?: number;
+}
+export declare namespace MatchmakingTicket {
+    
+    const filterSensitiveLog: (obj: MatchmakingTicket) => any;
+}
+
+export interface DescribeMatchmakingOutput {
+    
+    TicketList?: MatchmakingTicket[];
+}
+export declare namespace DescribeMatchmakingOutput {
+    
+    const filterSensitiveLog: (obj: DescribeMatchmakingOutput) => any;
+}
+
+export interface DescribeMatchmakingConfigurationsInput {
+    
+    Names?: string[];
+    
+    RuleSetName?: string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMatchmakingConfigurationsInput {
+    
+    const filterSensitiveLog: (obj: DescribeMatchmakingConfigurationsInput) => any;
+}
+
+export interface DescribeMatchmakingConfigurationsOutput {
+    
+    Configurations?: MatchmakingConfiguration[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMatchmakingConfigurationsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeMatchmakingConfigurationsOutput) => any;
+}
+
+export interface DescribeMatchmakingRuleSetsInput {
+    
+    Names?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMatchmakingRuleSetsInput {
+    
+    const filterSensitiveLog: (obj: DescribeMatchmakingRuleSetsInput) => any;
+}
+
+export interface DescribeMatchmakingRuleSetsOutput {
+    
+    RuleSets: MatchmakingRuleSet[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeMatchmakingRuleSetsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeMatchmakingRuleSetsOutput) => any;
+}
+
+export interface DescribePlayerSessionsInput {
+    
+    GameSessionId?: string;
+    
+    PlayerId?: string;
+    
+    PlayerSessionId?: string;
+    
+    PlayerSessionStatusFilter?: string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribePlayerSessionsInput {
+    
+    const filterSensitiveLog: (obj: DescribePlayerSessionsInput) => any;
+}
+
+export interface DescribePlayerSessionsOutput {
+    
+    PlayerSessions?: PlayerSession[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribePlayerSessionsOutput {
+    
+    const filterSensitiveLog: (obj: DescribePlayerSessionsOutput) => any;
+}
+
+export interface DescribeRuntimeConfigurationInput {
+    
+    FleetId: string | undefined;
+}
+export declare namespace DescribeRuntimeConfigurationInput {
+    
+    const filterSensitiveLog: (obj: DescribeRuntimeConfigurationInput) => any;
+}
+
+export interface DescribeRuntimeConfigurationOutput {
+    
+    RuntimeConfiguration?: RuntimeConfiguration;
+}
+export declare namespace DescribeRuntimeConfigurationOutput {
+    
+    const filterSensitiveLog: (obj: DescribeRuntimeConfigurationOutput) => any;
+}
+export declare enum ScalingStatusType {
+    ACTIVE = "ACTIVE",
+    DELETED = "DELETED",
+    DELETE_REQUESTED = "DELETE_REQUESTED",
+    DELETING = "DELETING",
+    ERROR = "ERROR",
+    UPDATE_REQUESTED = "UPDATE_REQUESTED",
+    UPDATING = "UPDATING"
+}
+
+export interface DescribeScalingPoliciesInput {
+    
+    FleetId: string | undefined;
+    
+    StatusFilter?: ScalingStatusType | string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+    
+    Location?: string;
+}
+export declare namespace DescribeScalingPoliciesInput {
+    
+    const filterSensitiveLog: (obj: DescribeScalingPoliciesInput) => any;
+}
+export declare type MetricName = "ActivatingGameSessions" | "ActiveGameSessions" | "ActiveInstances" | "AvailableGameSessions" | "AvailablePlayerSessions" | "CurrentPlayerSessions" | "IdleInstances" | "PercentAvailableGameSessions" | "PercentIdleInstances" | "QueueDepth" | "WaitTime";
+export declare enum PolicyType {
+    RuleBased = "RuleBased",
+    TargetBased = "TargetBased"
+}
+export declare enum ScalingAdjustmentType {
+    ChangeInCapacity = "ChangeInCapacity",
+    ExactCapacity = "ExactCapacity",
+    PercentChangeInCapacity = "PercentChangeInCapacity"
+}
+
+export interface TargetConfiguration {
+    
+    TargetValue: number | undefined;
+}
+export declare namespace TargetConfiguration {
+    
+    const filterSensitiveLog: (obj: TargetConfiguration) => any;
+}
+
+export interface ScalingPolicy {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    Name?: string;
+    
+    Status?: ScalingStatusType | string;
+    
+    ScalingAdjustment?: number;
+    
+    ScalingAdjustmentType?: ScalingAdjustmentType | string;
+    
+    ComparisonOperator?: ComparisonOperatorType | string;
+    
+    Threshold?: number;
+    
+    EvaluationPeriods?: number;
+    
+    MetricName?: MetricName | string;
+    
+    PolicyType?: PolicyType | string;
+    
+    TargetConfiguration?: TargetConfiguration;
+    
+    UpdateStatus?: LocationUpdateStatus | string;
+    
+    Location?: string;
+}
+export declare namespace ScalingPolicy {
+    
+    const filterSensitiveLog: (obj: ScalingPolicy) => any;
+}
+
+export interface DescribeScalingPoliciesOutput {
+    
+    ScalingPolicies?: ScalingPolicy[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeScalingPoliciesOutput {
+    
+    const filterSensitiveLog: (obj: DescribeScalingPoliciesOutput) => any;
+}
+export interface DescribeScriptInput {
+    
+    ScriptId: string | undefined;
+}
+export declare namespace DescribeScriptInput {
+    
+    const filterSensitiveLog: (obj: DescribeScriptInput) => any;
+}
+export interface DescribeScriptOutput {
+    
+    Script?: Script;
+}
+export declare namespace DescribeScriptOutput {
+    
+    const filterSensitiveLog: (obj: DescribeScriptOutput) => any;
+}
+export interface DescribeVpcPeeringAuthorizationsInput {
+}
+export declare namespace DescribeVpcPeeringAuthorizationsInput {
+    
+    const filterSensitiveLog: (obj: DescribeVpcPeeringAuthorizationsInput) => any;
+}
+export interface DescribeVpcPeeringAuthorizationsOutput {
+    
+    VpcPeeringAuthorizations?: VpcPeeringAuthorization[];
+}
+export declare namespace DescribeVpcPeeringAuthorizationsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeVpcPeeringAuthorizationsOutput) => any;
+}
+
+export interface DescribeVpcPeeringConnectionsInput {
+    
+    FleetId?: string;
+}
+export declare namespace DescribeVpcPeeringConnectionsInput {
+    
+    const filterSensitiveLog: (obj: DescribeVpcPeeringConnectionsInput) => any;
+}
+
+export interface VpcPeeringConnectionStatus {
+    
+    Code?: string;
+    
+    Message?: string;
+}
+export declare namespace VpcPeeringConnectionStatus {
+    
+    const filterSensitiveLog: (obj: VpcPeeringConnectionStatus) => any;
+}
+
+export interface VpcPeeringConnection {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    IpV4CidrBlock?: string;
+    
+    VpcPeeringConnectionId?: string;
+    
+    Status?: VpcPeeringConnectionStatus;
+    
+    PeerVpcId?: string;
+    
+    GameLiftVpcId?: string;
+}
+export declare namespace VpcPeeringConnection {
+    
+    const filterSensitiveLog: (obj: VpcPeeringConnection) => any;
+}
+
+export interface DescribeVpcPeeringConnectionsOutput {
+    
+    VpcPeeringConnections?: VpcPeeringConnection[];
+}
+export declare namespace DescribeVpcPeeringConnectionsOutput {
+    
+    const filterSensitiveLog: (obj: DescribeVpcPeeringConnectionsOutput) => any;
+}
+
+export interface DesiredPlayerSession {
+    
+    PlayerId?: string;
+    
+    PlayerData?: string;
+}
+export declare namespace DesiredPlayerSession {
+    
+    const filterSensitiveLog: (obj: DesiredPlayerSession) => any;
+}
+
+export interface GetGameSessionLogUrlInput {
+    
+    GameSessionId: string | undefined;
+}
+export declare namespace GetGameSessionLogUrlInput {
+    
+    const filterSensitiveLog: (obj: GetGameSessionLogUrlInput) => any;
+}
+
+export interface GetGameSessionLogUrlOutput {
+    
+    PreSignedUrl?: string;
+}
+export declare namespace GetGameSessionLogUrlOutput {
+    
+    const filterSensitiveLog: (obj: GetGameSessionLogUrlOutput) => any;
+}
+
+export interface GetInstanceAccessInput {
+    
+    FleetId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace GetInstanceAccessInput {
+    
+    const filterSensitiveLog: (obj: GetInstanceAccessInput) => any;
+}
+
+export interface InstanceCredentials {
+    
+    UserName?: string;
+    
+    Secret?: string;
+}
+export declare namespace InstanceCredentials {
+    
+    const filterSensitiveLog: (obj: InstanceCredentials) => any;
+}
+
+export interface InstanceAccess {
+    
+    FleetId?: string;
+    
+    InstanceId?: string;
+    
+    IpAddress?: string;
+    
+    OperatingSystem?: OperatingSystem | string;
+    
+    Credentials?: InstanceCredentials;
+}
+export declare namespace InstanceAccess {
+    
+    const filterSensitiveLog: (obj: InstanceAccess) => any;
+}
+
+export interface GetInstanceAccessOutput {
+    
+    InstanceAccess?: InstanceAccess;
+}
+export declare namespace GetInstanceAccessOutput {
+    
+    const filterSensitiveLog: (obj: GetInstanceAccessOutput) => any;
+}
+
+export interface ListAliasesInput {
+    
+    RoutingStrategyType?: RoutingStrategyType | string;
+    
+    Name?: string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListAliasesInput {
+    
+    const filterSensitiveLog: (obj: ListAliasesInput) => any;
+}
+
+export interface ListAliasesOutput {
+    
+    Aliases?: Alias[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAliasesOutput {
+    
+    const filterSensitiveLog: (obj: ListAliasesOutput) => any;
+}
+
+export interface ListBuildsInput {
+    
+    Status?: BuildStatus | string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListBuildsInput {
+    
+    const filterSensitiveLog: (obj: ListBuildsInput) => any;
+}
+
+export interface ListBuildsOutput {
+    
+    Builds?: Build[];
+    
+    NextToken?: string;
+}
+export declare namespace ListBuildsOutput {
+    
+    const filterSensitiveLog: (obj: ListBuildsOutput) => any;
+}
+
+export interface ListFleetsInput {
+    
+    BuildId?: string;
+    
+    ScriptId?: string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListFleetsInput {
+    
+    const filterSensitiveLog: (obj: ListFleetsInput) => any;
+}
+
+export interface ListFleetsOutput {
+    
+    FleetIds?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListFleetsOutput {
+    
+    const filterSensitiveLog: (obj: ListFleetsOutput) => any;
+}
+export interface ListGameServerGroupsInput {
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListGameServerGroupsInput {
+    
+    const filterSensitiveLog: (obj: ListGameServerGroupsInput) => any;
+}
+export interface ListGameServerGroupsOutput {
+    
+    GameServerGroups?: GameServerGroup[];
+    
+    NextToken?: string;
+}
+export declare namespace ListGameServerGroupsOutput {
+    
+    const filterSensitiveLog: (obj: ListGameServerGroupsOutput) => any;
+}
+export declare enum SortOrder {
+    ASCENDING = "ASCENDING",
+    DESCENDING = "DESCENDING"
+}
+export interface ListGameServersInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    SortOrder?: SortOrder | string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListGameServersInput {
+    
+    const filterSensitiveLog: (obj: ListGameServersInput) => any;
+}
+export interface ListGameServersOutput {
+    
+    GameServers?: GameServer[];
+    
+    NextToken?: string;
+}
+export declare namespace ListGameServersOutput {
+    
+    const filterSensitiveLog: (obj: ListGameServersOutput) => any;
+}
+export interface ListScriptsInput {
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListScriptsInput {
+    
+    const filterSensitiveLog: (obj: ListScriptsInput) => any;
+}
+export interface ListScriptsOutput {
+    
+    Scripts?: Script[];
+    
+    NextToken?: string;
+}
+export declare namespace ListScriptsOutput {
+    
+    const filterSensitiveLog: (obj: ListScriptsOutput) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceARN: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export interface PutScalingPolicyInput {
+    
+    Name: string | undefined;
+    
+    FleetId: string | undefined;
+    
+    ScalingAdjustment?: number;
+    
+    ScalingAdjustmentType?: ScalingAdjustmentType | string;
+    
+    Threshold?: number;
+    
+    ComparisonOperator?: ComparisonOperatorType | string;
+    
+    EvaluationPeriods?: number;
+    
+    MetricName: MetricName | string | undefined;
+    
+    PolicyType?: PolicyType | string;
+    
+    TargetConfiguration?: TargetConfiguration;
+}
+export declare namespace PutScalingPolicyInput {
+    
+    const filterSensitiveLog: (obj: PutScalingPolicyInput) => any;
+}
+
+export interface PutScalingPolicyOutput {
+    
+    Name?: string;
+}
+export declare namespace PutScalingPolicyOutput {
+    
+    const filterSensitiveLog: (obj: PutScalingPolicyOutput) => any;
+}
+export interface RegisterGameServerInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    GameServerId: string | undefined;
+    
+    InstanceId: string | undefined;
+    
+    ConnectionInfo?: string;
+    
+    GameServerData?: string;
+}
+export declare namespace RegisterGameServerInput {
+    
+    const filterSensitiveLog: (obj: RegisterGameServerInput) => any;
+}
+export interface RegisterGameServerOutput {
+    
+    GameServer?: GameServer;
+}
+export declare namespace RegisterGameServerOutput {
+    
+    const filterSensitiveLog: (obj: RegisterGameServerOutput) => any;
+}
+
+export interface RequestUploadCredentialsInput {
+    
+    BuildId: string | undefined;
+}
+export declare namespace RequestUploadCredentialsInput {
+    
+    const filterSensitiveLog: (obj: RequestUploadCredentialsInput) => any;
+}
+
+export interface RequestUploadCredentialsOutput {
+    
+    UploadCredentials?: AwsCredentials;
+    
+    StorageLocation?: S3Location;
+}
+export declare namespace RequestUploadCredentialsOutput {
+    
+    const filterSensitiveLog: (obj: RequestUploadCredentialsOutput) => any;
+}
+
+export interface ResolveAliasInput {
+    
+    AliasId: string | undefined;
+}
+export declare namespace ResolveAliasInput {
+    
+    const filterSensitiveLog: (obj: ResolveAliasInput) => any;
+}
+
+export interface ResolveAliasOutput {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+}
+export declare namespace ResolveAliasOutput {
+    
+    const filterSensitiveLog: (obj: ResolveAliasOutput) => any;
+}
+export interface ResumeGameServerGroupInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    ResumeActions: (GameServerGroupAction | string)[] | undefined;
+}
+export declare namespace ResumeGameServerGroupInput {
+    
+    const filterSensitiveLog: (obj: ResumeGameServerGroupInput) => any;
+}
+export interface ResumeGameServerGroupOutput {
+    
+    GameServerGroup?: GameServerGroup;
+}
+export declare namespace ResumeGameServerGroupOutput {
+    
+    const filterSensitiveLog: (obj: ResumeGameServerGroupOutput) => any;
+}
+
+export interface SearchGameSessionsInput {
+    
+    FleetId?: string;
+    
+    AliasId?: string;
+    
+    Location?: string;
+    
+    FilterExpression?: string;
+    
+    SortExpression?: string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace SearchGameSessionsInput {
+    
+    const filterSensitiveLog: (obj: SearchGameSessionsInput) => any;
+}
+
+export interface SearchGameSessionsOutput {
+    
+    GameSessions?: GameSession[];
+    
+    NextToken?: string;
+}
+export declare namespace SearchGameSessionsOutput {
+    
+    const filterSensitiveLog: (obj: SearchGameSessionsOutput) => any;
+}
+
+export interface StartFleetActionsInput {
+    
+    FleetId: string | undefined;
+    
+    Actions: (FleetAction | string)[] | undefined;
+    
+    Location?: string;
+}
+export declare namespace StartFleetActionsInput {
+    
+    const filterSensitiveLog: (obj: StartFleetActionsInput) => any;
+}
+
+export interface StartFleetActionsOutput {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+}
+export declare namespace StartFleetActionsOutput {
+    
+    const filterSensitiveLog: (obj: StartFleetActionsOutput) => any;
+}
+
+export interface StartGameSessionPlacementInput {
+    
+    PlacementId: string | undefined;
+    
+    GameSessionQueueName: string | undefined;
+    
+    GameProperties?: GameProperty[];
+    
+    MaximumPlayerSessionCount: number | undefined;
+    
+    GameSessionName?: string;
+    
+    PlayerLatencies?: PlayerLatency[];
+    
+    DesiredPlayerSessions?: DesiredPlayerSession[];
+    
+    GameSessionData?: string;
+}
+export declare namespace StartGameSessionPlacementInput {
+    
+    const filterSensitiveLog: (obj: StartGameSessionPlacementInput) => any;
+}
+
+export interface StartGameSessionPlacementOutput {
+    
+    GameSessionPlacement?: GameSessionPlacement;
+}
+export declare namespace StartGameSessionPlacementOutput {
+    
+    const filterSensitiveLog: (obj: StartGameSessionPlacementOutput) => any;
+}
+
+export interface StartMatchBackfillInput {
+    
+    TicketId?: string;
+    
+    ConfigurationName: string | undefined;
+    
+    GameSessionArn?: string;
+    
+    Players: Player[] | undefined;
+}
+export declare namespace StartMatchBackfillInput {
+    
+    const filterSensitiveLog: (obj: StartMatchBackfillInput) => any;
+}
+
+export interface StartMatchBackfillOutput {
+    
+    MatchmakingTicket?: MatchmakingTicket;
+}
+export declare namespace StartMatchBackfillOutput {
+    
+    const filterSensitiveLog: (obj: StartMatchBackfillOutput) => any;
+}
+
+export interface StartMatchmakingInput {
+    
+    TicketId?: string;
+    
+    ConfigurationName: string | undefined;
+    
+    Players: Player[] | undefined;
+}
+export declare namespace StartMatchmakingInput {
+    
+    const filterSensitiveLog: (obj: StartMatchmakingInput) => any;
+}
+
+export interface StartMatchmakingOutput {
+    
+    MatchmakingTicket?: MatchmakingTicket;
+}
+export declare namespace StartMatchmakingOutput {
+    
+    const filterSensitiveLog: (obj: StartMatchmakingOutput) => any;
+}
+
+export interface StopFleetActionsInput {
+    
+    FleetId: string | undefined;
+    
+    Actions: (FleetAction | string)[] | undefined;
+    
+    Location?: string;
+}
+export declare namespace StopFleetActionsInput {
+    
+    const filterSensitiveLog: (obj: StopFleetActionsInput) => any;
+}
+
+export interface StopFleetActionsOutput {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+}
+export declare namespace StopFleetActionsOutput {
+    
+    const filterSensitiveLog: (obj: StopFleetActionsOutput) => any;
+}
+
+export interface StopGameSessionPlacementInput {
+    
+    PlacementId: string | undefined;
+}
+export declare namespace StopGameSessionPlacementInput {
+    
+    const filterSensitiveLog: (obj: StopGameSessionPlacementInput) => any;
+}
+
+export interface StopGameSessionPlacementOutput {
+    
+    GameSessionPlacement?: GameSessionPlacement;
+}
+export declare namespace StopGameSessionPlacementOutput {
+    
+    const filterSensitiveLog: (obj: StopGameSessionPlacementOutput) => any;
+}
+
+export interface StopMatchmakingInput {
+    
+    TicketId: string | undefined;
+}
+export declare namespace StopMatchmakingInput {
+    
+    const filterSensitiveLog: (obj: StopMatchmakingInput) => any;
+}
+export interface StopMatchmakingOutput {
+}
+export declare namespace StopMatchmakingOutput {
+    
+    const filterSensitiveLog: (obj: StopMatchmakingOutput) => any;
+}
+export interface SuspendGameServerGroupInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    SuspendActions: (GameServerGroupAction | string)[] | undefined;
+}
+export declare namespace SuspendGameServerGroupInput {
+    
+    const filterSensitiveLog: (obj: SuspendGameServerGroupInput) => any;
+}
+export interface SuspendGameServerGroupOutput {
+    
+    GameServerGroup?: GameServerGroup;
+}
+export declare namespace SuspendGameServerGroupOutput {
+    
+    const filterSensitiveLog: (obj: SuspendGameServerGroupOutput) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceARN: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceARN: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+
+export interface UpdateAliasInput {
+    
+    AliasId: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    RoutingStrategy?: RoutingStrategy;
+}
+export declare namespace UpdateAliasInput {
+    
+    const filterSensitiveLog: (obj: UpdateAliasInput) => any;
+}
+
+export interface UpdateAliasOutput {
+    
+    Alias?: Alias;
+}
+export declare namespace UpdateAliasOutput {
+    
+    const filterSensitiveLog: (obj: UpdateAliasOutput) => any;
+}
+
+export interface UpdateBuildInput {
+    
+    BuildId: string | undefined;
+    
+    Name?: string;
+    
+    Version?: string;
+}
+export declare namespace UpdateBuildInput {
+    
+    const filterSensitiveLog: (obj: UpdateBuildInput) => any;
+}
+
+export interface UpdateBuildOutput {
+    
+    Build?: Build;
+}
+export declare namespace UpdateBuildOutput {
+    
+    const filterSensitiveLog: (obj: UpdateBuildOutput) => any;
+}
+
+export interface UpdateFleetAttributesInput {
+    
+    FleetId: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    NewGameSessionProtectionPolicy?: ProtectionPolicy | string;
+    
+    ResourceCreationLimitPolicy?: ResourceCreationLimitPolicy;
+    
+    MetricGroups?: string[];
+}
+export declare namespace UpdateFleetAttributesInput {
+    
+    const filterSensitiveLog: (obj: UpdateFleetAttributesInput) => any;
+}
+
+export interface UpdateFleetAttributesOutput {
+    
+    FleetId?: string;
+}
+export declare namespace UpdateFleetAttributesOutput {
+    
+    const filterSensitiveLog: (obj: UpdateFleetAttributesOutput) => any;
+}
+
+export interface UpdateFleetCapacityInput {
+    
+    FleetId: string | undefined;
+    
+    DesiredInstances?: number;
+    
+    MinSize?: number;
+    
+    MaxSize?: number;
+    
+    Location?: string;
+}
+export declare namespace UpdateFleetCapacityInput {
+    
+    const filterSensitiveLog: (obj: UpdateFleetCapacityInput) => any;
+}
+
+export interface UpdateFleetCapacityOutput {
+    
+    FleetId?: string;
+    
+    FleetArn?: string;
+    
+    Location?: string;
+}
+export declare namespace UpdateFleetCapacityOutput {
+    
+    const filterSensitiveLog: (obj: UpdateFleetCapacityOutput) => any;
+}
+
+export interface UpdateFleetPortSettingsInput {
+    
+    FleetId: string | undefined;
+    
+    InboundPermissionAuthorizations?: IpPermission[];
+    
+    InboundPermissionRevocations?: IpPermission[];
+}
+export declare namespace UpdateFleetPortSettingsInput {
+    
+    const filterSensitiveLog: (obj: UpdateFleetPortSettingsInput) => any;
+}
+
+export interface UpdateFleetPortSettingsOutput {
+    
+    FleetId?: string;
+}
+export declare namespace UpdateFleetPortSettingsOutput {
+    
+    const filterSensitiveLog: (obj: UpdateFleetPortSettingsOutput) => any;
+}
+export declare enum GameServerHealthCheck {
+    HEALTHY = "HEALTHY"
+}
+export interface UpdateGameServerInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    GameServerId: string | undefined;
+    
+    GameServerData?: string;
+    
+    UtilizationStatus?: GameServerUtilizationStatus | string;
+    
+    HealthCheck?: GameServerHealthCheck | string;
+}
+export declare namespace UpdateGameServerInput {
+    
+    const filterSensitiveLog: (obj: UpdateGameServerInput) => any;
+}
+export interface UpdateGameServerOutput {
+    
+    GameServer?: GameServer;
+}
+export declare namespace UpdateGameServerOutput {
+    
+    const filterSensitiveLog: (obj: UpdateGameServerOutput) => any;
+}
+export interface UpdateGameServerGroupInput {
+    
+    GameServerGroupName: string | undefined;
+    
+    RoleArn?: string;
+    
+    InstanceDefinitions?: InstanceDefinition[];
+    
+    GameServerProtectionPolicy?: GameServerProtectionPolicy | string;
+    
+    BalancingStrategy?: BalancingStrategy | string;
+}
+export declare namespace UpdateGameServerGroupInput {
+    
+    const filterSensitiveLog: (obj: UpdateGameServerGroupInput) => any;
+}
+export interface UpdateGameServerGroupOutput {
+    
+    GameServerGroup?: GameServerGroup;
+}
+export declare namespace UpdateGameServerGroupOutput {
+    
+    const filterSensitiveLog: (obj: UpdateGameServerGroupOutput) => any;
+}
+
+export interface UpdateGameSessionInput {
+    
+    GameSessionId: string | undefined;
+    
+    MaximumPlayerSessionCount?: number;
+    
+    Name?: string;
+    
+    PlayerSessionCreationPolicy?: PlayerSessionCreationPolicy | string;
+    
+    ProtectionPolicy?: ProtectionPolicy | string;
+}
+export declare namespace UpdateGameSessionInput {
+    
+    const filterSensitiveLog: (obj: UpdateGameSessionInput) => any;
+}
+
+export interface UpdateGameSessionOutput {
+    
+    GameSession?: GameSession;
+}
+export declare namespace UpdateGameSessionOutput {
+    
+    const filterSensitiveLog: (obj: UpdateGameSessionOutput) => any;
+}
+
+export interface UpdateGameSessionQueueInput {
+    
+    Name: string | undefined;
+    
+    TimeoutInSeconds?: number;
+    
+    PlayerLatencyPolicies?: PlayerLatencyPolicy[];
+    
+    Destinations?: GameSessionQueueDestination[];
+    
+    FilterConfiguration?: FilterConfiguration;
+    
+    PriorityConfiguration?: PriorityConfiguration;
+    
+    CustomEventData?: string;
+    
+    NotificationTarget?: string;
+}
+export declare namespace UpdateGameSessionQueueInput {
+    
+    const filterSensitiveLog: (obj: UpdateGameSessionQueueInput) => any;
+}
+
+export interface UpdateGameSessionQueueOutput {
+    
+    GameSessionQueue?: GameSessionQueue;
+}
+export declare namespace UpdateGameSessionQueueOutput {
+    
+    const filterSensitiveLog: (obj: UpdateGameSessionQueueOutput) => any;
+}
+
+export interface UpdateMatchmakingConfigurationInput {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    GameSessionQueueArns?: string[];
+    
+    RequestTimeoutSeconds?: number;
+    
+    AcceptanceTimeoutSeconds?: number;
+    
+    AcceptanceRequired?: boolean;
+    
+    RuleSetName?: string;
+    
+    NotificationTarget?: string;
+    
+    AdditionalPlayerCount?: number;
+    
+    CustomEventData?: string;
+    
+    GameProperties?: GameProperty[];
+    
+    GameSessionData?: string;
+    
+    BackfillMode?: BackfillMode | string;
+    
+    FlexMatchMode?: FlexMatchMode | string;
+}
+export declare namespace UpdateMatchmakingConfigurationInput {
+    
+    const filterSensitiveLog: (obj: UpdateMatchmakingConfigurationInput) => any;
+}
+
+export interface UpdateMatchmakingConfigurationOutput {
+    
+    Configuration?: MatchmakingConfiguration;
+}
+export declare namespace UpdateMatchmakingConfigurationOutput {
+    
+    const filterSensitiveLog: (obj: UpdateMatchmakingConfigurationOutput) => any;
+}
+
+export interface UpdateRuntimeConfigurationInput {
+    
+    FleetId: string | undefined;
+    
+    RuntimeConfiguration: RuntimeConfiguration | undefined;
+}
+export declare namespace UpdateRuntimeConfigurationInput {
+    
+    const filterSensitiveLog: (obj: UpdateRuntimeConfigurationInput) => any;
+}
+
+export interface UpdateRuntimeConfigurationOutput {
+    
+    RuntimeConfiguration?: RuntimeConfiguration;
+}
+export declare namespace UpdateRuntimeConfigurationOutput {
+    
+    const filterSensitiveLog: (obj: UpdateRuntimeConfigurationOutput) => any;
+}
+export interface UpdateScriptInput {
+    
+    ScriptId: string | undefined;
+    
+    Name?: string;
+    
+    Version?: string;
+    
+    StorageLocation?: S3Location;
+    
+    ZipFile?: Uint8Array;
+}
+export declare namespace UpdateScriptInput {
+    
+    const filterSensitiveLog: (obj: UpdateScriptInput) => any;
+}
+export interface UpdateScriptOutput {
+    
+    Script?: Script;
+}
+export declare namespace UpdateScriptOutput {
+    
+    const filterSensitiveLog: (obj: UpdateScriptOutput) => any;
+}
+
+export interface ValidateMatchmakingRuleSetInput {
+    
+    RuleSetBody: string | undefined;
+}
+export declare namespace ValidateMatchmakingRuleSetInput {
+    
+    const filterSensitiveLog: (obj: ValidateMatchmakingRuleSetInput) => any;
+}
+
+export interface ValidateMatchmakingRuleSetOutput {
+    
+    Valid?: boolean;
+}
+export declare namespace ValidateMatchmakingRuleSetOutput {
+    
+    const filterSensitiveLog: (obj: ValidateMatchmakingRuleSetOutput) => any;
+}