pulumiTypes.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package gamelift

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

var _ = internal.GetEnvOrDefault

type AliasRoutingStrategy struct {
	// ID of the GameLift Fleet to point the alias to.
	FleetId *string `pulumi:"fleetId"`
	// Message text to be used with the `TERMINAL` routing strategy.
	Message *string `pulumi:"message"`
	// Type of routing strategyE.g., `SIMPLE` or `TERMINAL`
	Type string `pulumi:"type"`
}

// AliasRoutingStrategyInput is an input type that accepts AliasRoutingStrategyArgs and AliasRoutingStrategyOutput values.
// You can construct a concrete instance of `AliasRoutingStrategyInput` via:
//
//	AliasRoutingStrategyArgs{...}
type AliasRoutingStrategyInput interface {
	pulumi.Input

	ToAliasRoutingStrategyOutput() AliasRoutingStrategyOutput
	ToAliasRoutingStrategyOutputWithContext(context.Context) AliasRoutingStrategyOutput
}

type AliasRoutingStrategyArgs struct {
	// ID of the GameLift Fleet to point the alias to.
	FleetId pulumi.StringPtrInput `pulumi:"fleetId"`
	// Message text to be used with the `TERMINAL` routing strategy.
	Message pulumi.StringPtrInput `pulumi:"message"`
	// Type of routing strategyE.g., `SIMPLE` or `TERMINAL`
	Type pulumi.StringInput `pulumi:"type"`
}

func (AliasRoutingStrategyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AliasRoutingStrategy)(nil)).Elem()
}

func (i AliasRoutingStrategyArgs) ToAliasRoutingStrategyOutput() AliasRoutingStrategyOutput {
	return i.ToAliasRoutingStrategyOutputWithContext(context.Background())
}

func (i AliasRoutingStrategyArgs) ToAliasRoutingStrategyOutputWithContext(ctx context.Context) AliasRoutingStrategyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AliasRoutingStrategyOutput)
}

func (i AliasRoutingStrategyArgs) ToAliasRoutingStrategyPtrOutput() AliasRoutingStrategyPtrOutput {
	return i.ToAliasRoutingStrategyPtrOutputWithContext(context.Background())
}

func (i AliasRoutingStrategyArgs) ToAliasRoutingStrategyPtrOutputWithContext(ctx context.Context) AliasRoutingStrategyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AliasRoutingStrategyOutput).ToAliasRoutingStrategyPtrOutputWithContext(ctx)
}

// AliasRoutingStrategyPtrInput is an input type that accepts AliasRoutingStrategyArgs, AliasRoutingStrategyPtr and AliasRoutingStrategyPtrOutput values.
// You can construct a concrete instance of `AliasRoutingStrategyPtrInput` via:
//
//	        AliasRoutingStrategyArgs{...}
//
//	or:
//
//	        nil
type AliasRoutingStrategyPtrInput interface {
	pulumi.Input

	ToAliasRoutingStrategyPtrOutput() AliasRoutingStrategyPtrOutput
	ToAliasRoutingStrategyPtrOutputWithContext(context.Context) AliasRoutingStrategyPtrOutput
}

type aliasRoutingStrategyPtrType AliasRoutingStrategyArgs

func AliasRoutingStrategyPtr(v *AliasRoutingStrategyArgs) AliasRoutingStrategyPtrInput {
	return (*aliasRoutingStrategyPtrType)(v)
}

func (*aliasRoutingStrategyPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AliasRoutingStrategy)(nil)).Elem()
}

func (i *aliasRoutingStrategyPtrType) ToAliasRoutingStrategyPtrOutput() AliasRoutingStrategyPtrOutput {
	return i.ToAliasRoutingStrategyPtrOutputWithContext(context.Background())
}

func (i *aliasRoutingStrategyPtrType) ToAliasRoutingStrategyPtrOutputWithContext(ctx context.Context) AliasRoutingStrategyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AliasRoutingStrategyPtrOutput)
}

type AliasRoutingStrategyOutput struct{ *pulumi.OutputState }

func (AliasRoutingStrategyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AliasRoutingStrategy)(nil)).Elem()
}

func (o AliasRoutingStrategyOutput) ToAliasRoutingStrategyOutput() AliasRoutingStrategyOutput {
	return o
}

func (o AliasRoutingStrategyOutput) ToAliasRoutingStrategyOutputWithContext(ctx context.Context) AliasRoutingStrategyOutput {
	return o
}

func (o AliasRoutingStrategyOutput) ToAliasRoutingStrategyPtrOutput() AliasRoutingStrategyPtrOutput {
	return o.ToAliasRoutingStrategyPtrOutputWithContext(context.Background())
}

func (o AliasRoutingStrategyOutput) ToAliasRoutingStrategyPtrOutputWithContext(ctx context.Context) AliasRoutingStrategyPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AliasRoutingStrategy) *AliasRoutingStrategy {
		return &v
	}).(AliasRoutingStrategyPtrOutput)
}

// ID of the GameLift Fleet to point the alias to.
func (o AliasRoutingStrategyOutput) FleetId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AliasRoutingStrategy) *string { return v.FleetId }).(pulumi.StringPtrOutput)
}

// Message text to be used with the `TERMINAL` routing strategy.
func (o AliasRoutingStrategyOutput) Message() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AliasRoutingStrategy) *string { return v.Message }).(pulumi.StringPtrOutput)
}

// Type of routing strategyE.g., `SIMPLE` or `TERMINAL`
func (o AliasRoutingStrategyOutput) Type() pulumi.StringOutput {
	return o.ApplyT(func(v AliasRoutingStrategy) string { return v.Type }).(pulumi.StringOutput)
}

type AliasRoutingStrategyPtrOutput struct{ *pulumi.OutputState }

func (AliasRoutingStrategyPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AliasRoutingStrategy)(nil)).Elem()
}

func (o AliasRoutingStrategyPtrOutput) ToAliasRoutingStrategyPtrOutput() AliasRoutingStrategyPtrOutput {
	return o
}

func (o AliasRoutingStrategyPtrOutput) ToAliasRoutingStrategyPtrOutputWithContext(ctx context.Context) AliasRoutingStrategyPtrOutput {
	return o
}

func (o AliasRoutingStrategyPtrOutput) Elem() AliasRoutingStrategyOutput {
	return o.ApplyT(func(v *AliasRoutingStrategy) AliasRoutingStrategy {
		if v != nil {
			return *v
		}
		var ret AliasRoutingStrategy
		return ret
	}).(AliasRoutingStrategyOutput)
}

// ID of the GameLift Fleet to point the alias to.
func (o AliasRoutingStrategyPtrOutput) FleetId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AliasRoutingStrategy) *string {
		if v == nil {
			return nil
		}
		return v.FleetId
	}).(pulumi.StringPtrOutput)
}

// Message text to be used with the `TERMINAL` routing strategy.
func (o AliasRoutingStrategyPtrOutput) Message() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AliasRoutingStrategy) *string {
		if v == nil {
			return nil
		}
		return v.Message
	}).(pulumi.StringPtrOutput)
}

// Type of routing strategyE.g., `SIMPLE` or `TERMINAL`
func (o AliasRoutingStrategyPtrOutput) Type() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AliasRoutingStrategy) *string {
		if v == nil {
			return nil
		}
		return &v.Type
	}).(pulumi.StringPtrOutput)
}

type BuildStorageLocation struct {
	// Name of your S3 bucket.
	Bucket string `pulumi:"bucket"`
	// Name of the zip file containing your build files.
	Key string `pulumi:"key"`
	// A specific version of the file. If not set, the latest version of the file is retrieved.
	ObjectVersion *string `pulumi:"objectVersion"`
	// ARN of the access role that allows Amazon GameLift to access your S3 bucket.
	RoleArn string `pulumi:"roleArn"`
}

// BuildStorageLocationInput is an input type that accepts BuildStorageLocationArgs and BuildStorageLocationOutput values.
// You can construct a concrete instance of `BuildStorageLocationInput` via:
//
//	BuildStorageLocationArgs{...}
type BuildStorageLocationInput interface {
	pulumi.Input

	ToBuildStorageLocationOutput() BuildStorageLocationOutput
	ToBuildStorageLocationOutputWithContext(context.Context) BuildStorageLocationOutput
}

type BuildStorageLocationArgs struct {
	// Name of your S3 bucket.
	Bucket pulumi.StringInput `pulumi:"bucket"`
	// Name of the zip file containing your build files.
	Key pulumi.StringInput `pulumi:"key"`
	// A specific version of the file. If not set, the latest version of the file is retrieved.
	ObjectVersion pulumi.StringPtrInput `pulumi:"objectVersion"`
	// ARN of the access role that allows Amazon GameLift to access your S3 bucket.
	RoleArn pulumi.StringInput `pulumi:"roleArn"`
}

func (BuildStorageLocationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*BuildStorageLocation)(nil)).Elem()
}

func (i BuildStorageLocationArgs) ToBuildStorageLocationOutput() BuildStorageLocationOutput {
	return i.ToBuildStorageLocationOutputWithContext(context.Background())
}

func (i BuildStorageLocationArgs) ToBuildStorageLocationOutputWithContext(ctx context.Context) BuildStorageLocationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BuildStorageLocationOutput)
}

func (i BuildStorageLocationArgs) ToBuildStorageLocationPtrOutput() BuildStorageLocationPtrOutput {
	return i.ToBuildStorageLocationPtrOutputWithContext(context.Background())
}

func (i BuildStorageLocationArgs) ToBuildStorageLocationPtrOutputWithContext(ctx context.Context) BuildStorageLocationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BuildStorageLocationOutput).ToBuildStorageLocationPtrOutputWithContext(ctx)
}

// BuildStorageLocationPtrInput is an input type that accepts BuildStorageLocationArgs, BuildStorageLocationPtr and BuildStorageLocationPtrOutput values.
// You can construct a concrete instance of `BuildStorageLocationPtrInput` via:
//
//	        BuildStorageLocationArgs{...}
//
//	or:
//
//	        nil
type BuildStorageLocationPtrInput interface {
	pulumi.Input

	ToBuildStorageLocationPtrOutput() BuildStorageLocationPtrOutput
	ToBuildStorageLocationPtrOutputWithContext(context.Context) BuildStorageLocationPtrOutput
}

type buildStorageLocationPtrType BuildStorageLocationArgs

func BuildStorageLocationPtr(v *BuildStorageLocationArgs) BuildStorageLocationPtrInput {
	return (*buildStorageLocationPtrType)(v)
}

func (*buildStorageLocationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**BuildStorageLocation)(nil)).Elem()
}

func (i *buildStorageLocationPtrType) ToBuildStorageLocationPtrOutput() BuildStorageLocationPtrOutput {
	return i.ToBuildStorageLocationPtrOutputWithContext(context.Background())
}

func (i *buildStorageLocationPtrType) ToBuildStorageLocationPtrOutputWithContext(ctx context.Context) BuildStorageLocationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(BuildStorageLocationPtrOutput)
}

type BuildStorageLocationOutput struct{ *pulumi.OutputState }

func (BuildStorageLocationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*BuildStorageLocation)(nil)).Elem()
}

func (o BuildStorageLocationOutput) ToBuildStorageLocationOutput() BuildStorageLocationOutput {
	return o
}

func (o BuildStorageLocationOutput) ToBuildStorageLocationOutputWithContext(ctx context.Context) BuildStorageLocationOutput {
	return o
}

func (o BuildStorageLocationOutput) ToBuildStorageLocationPtrOutput() BuildStorageLocationPtrOutput {
	return o.ToBuildStorageLocationPtrOutputWithContext(context.Background())
}

func (o BuildStorageLocationOutput) ToBuildStorageLocationPtrOutputWithContext(ctx context.Context) BuildStorageLocationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v BuildStorageLocation) *BuildStorageLocation {
		return &v
	}).(BuildStorageLocationPtrOutput)
}

// Name of your S3 bucket.
func (o BuildStorageLocationOutput) Bucket() pulumi.StringOutput {
	return o.ApplyT(func(v BuildStorageLocation) string { return v.Bucket }).(pulumi.StringOutput)
}

// Name of the zip file containing your build files.
func (o BuildStorageLocationOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v BuildStorageLocation) string { return v.Key }).(pulumi.StringOutput)
}

// A specific version of the file. If not set, the latest version of the file is retrieved.
func (o BuildStorageLocationOutput) ObjectVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v BuildStorageLocation) *string { return v.ObjectVersion }).(pulumi.StringPtrOutput)
}

// ARN of the access role that allows Amazon GameLift to access your S3 bucket.
func (o BuildStorageLocationOutput) RoleArn() pulumi.StringOutput {
	return o.ApplyT(func(v BuildStorageLocation) string { return v.RoleArn }).(pulumi.StringOutput)
}

type BuildStorageLocationPtrOutput struct{ *pulumi.OutputState }

func (BuildStorageLocationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**BuildStorageLocation)(nil)).Elem()
}

func (o BuildStorageLocationPtrOutput) ToBuildStorageLocationPtrOutput() BuildStorageLocationPtrOutput {
	return o
}

func (o BuildStorageLocationPtrOutput) ToBuildStorageLocationPtrOutputWithContext(ctx context.Context) BuildStorageLocationPtrOutput {
	return o
}

func (o BuildStorageLocationPtrOutput) Elem() BuildStorageLocationOutput {
	return o.ApplyT(func(v *BuildStorageLocation) BuildStorageLocation {
		if v != nil {
			return *v
		}
		var ret BuildStorageLocation
		return ret
	}).(BuildStorageLocationOutput)
}

// Name of your S3 bucket.
func (o BuildStorageLocationPtrOutput) Bucket() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BuildStorageLocation) *string {
		if v == nil {
			return nil
		}
		return &v.Bucket
	}).(pulumi.StringPtrOutput)
}

// Name of the zip file containing your build files.
func (o BuildStorageLocationPtrOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BuildStorageLocation) *string {
		if v == nil {
			return nil
		}
		return &v.Key
	}).(pulumi.StringPtrOutput)
}

// A specific version of the file. If not set, the latest version of the file is retrieved.
func (o BuildStorageLocationPtrOutput) ObjectVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BuildStorageLocation) *string {
		if v == nil {
			return nil
		}
		return v.ObjectVersion
	}).(pulumi.StringPtrOutput)
}

// ARN of the access role that allows Amazon GameLift to access your S3 bucket.
func (o BuildStorageLocationPtrOutput) RoleArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *BuildStorageLocation) *string {
		if v == nil {
			return nil
		}
		return &v.RoleArn
	}).(pulumi.StringPtrOutput)
}

type FleetCertificateConfiguration struct {
	// Indicates whether a TLS/SSL certificate is generated for a fleet. Valid values are `DISABLED` and `GENERATED`. Default value is `DISABLED`.
	CertificateType *string `pulumi:"certificateType"`
}

// FleetCertificateConfigurationInput is an input type that accepts FleetCertificateConfigurationArgs and FleetCertificateConfigurationOutput values.
// You can construct a concrete instance of `FleetCertificateConfigurationInput` via:
//
//	FleetCertificateConfigurationArgs{...}
type FleetCertificateConfigurationInput interface {
	pulumi.Input

	ToFleetCertificateConfigurationOutput() FleetCertificateConfigurationOutput
	ToFleetCertificateConfigurationOutputWithContext(context.Context) FleetCertificateConfigurationOutput
}

type FleetCertificateConfigurationArgs struct {
	// Indicates whether a TLS/SSL certificate is generated for a fleet. Valid values are `DISABLED` and `GENERATED`. Default value is `DISABLED`.
	CertificateType pulumi.StringPtrInput `pulumi:"certificateType"`
}

func (FleetCertificateConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*FleetCertificateConfiguration)(nil)).Elem()
}

func (i FleetCertificateConfigurationArgs) ToFleetCertificateConfigurationOutput() FleetCertificateConfigurationOutput {
	return i.ToFleetCertificateConfigurationOutputWithContext(context.Background())
}

func (i FleetCertificateConfigurationArgs) ToFleetCertificateConfigurationOutputWithContext(ctx context.Context) FleetCertificateConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetCertificateConfigurationOutput)
}

func (i FleetCertificateConfigurationArgs) ToFleetCertificateConfigurationPtrOutput() FleetCertificateConfigurationPtrOutput {
	return i.ToFleetCertificateConfigurationPtrOutputWithContext(context.Background())
}

func (i FleetCertificateConfigurationArgs) ToFleetCertificateConfigurationPtrOutputWithContext(ctx context.Context) FleetCertificateConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetCertificateConfigurationOutput).ToFleetCertificateConfigurationPtrOutputWithContext(ctx)
}

// FleetCertificateConfigurationPtrInput is an input type that accepts FleetCertificateConfigurationArgs, FleetCertificateConfigurationPtr and FleetCertificateConfigurationPtrOutput values.
// You can construct a concrete instance of `FleetCertificateConfigurationPtrInput` via:
//
//	        FleetCertificateConfigurationArgs{...}
//
//	or:
//
//	        nil
type FleetCertificateConfigurationPtrInput interface {
	pulumi.Input

	ToFleetCertificateConfigurationPtrOutput() FleetCertificateConfigurationPtrOutput
	ToFleetCertificateConfigurationPtrOutputWithContext(context.Context) FleetCertificateConfigurationPtrOutput
}

type fleetCertificateConfigurationPtrType FleetCertificateConfigurationArgs

func FleetCertificateConfigurationPtr(v *FleetCertificateConfigurationArgs) FleetCertificateConfigurationPtrInput {
	return (*fleetCertificateConfigurationPtrType)(v)
}

func (*fleetCertificateConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**FleetCertificateConfiguration)(nil)).Elem()
}

func (i *fleetCertificateConfigurationPtrType) ToFleetCertificateConfigurationPtrOutput() FleetCertificateConfigurationPtrOutput {
	return i.ToFleetCertificateConfigurationPtrOutputWithContext(context.Background())
}

func (i *fleetCertificateConfigurationPtrType) ToFleetCertificateConfigurationPtrOutputWithContext(ctx context.Context) FleetCertificateConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetCertificateConfigurationPtrOutput)
}

type FleetCertificateConfigurationOutput struct{ *pulumi.OutputState }

func (FleetCertificateConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*FleetCertificateConfiguration)(nil)).Elem()
}

func (o FleetCertificateConfigurationOutput) ToFleetCertificateConfigurationOutput() FleetCertificateConfigurationOutput {
	return o
}

func (o FleetCertificateConfigurationOutput) ToFleetCertificateConfigurationOutputWithContext(ctx context.Context) FleetCertificateConfigurationOutput {
	return o
}

func (o FleetCertificateConfigurationOutput) ToFleetCertificateConfigurationPtrOutput() FleetCertificateConfigurationPtrOutput {
	return o.ToFleetCertificateConfigurationPtrOutputWithContext(context.Background())
}

func (o FleetCertificateConfigurationOutput) ToFleetCertificateConfigurationPtrOutputWithContext(ctx context.Context) FleetCertificateConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v FleetCertificateConfiguration) *FleetCertificateConfiguration {
		return &v
	}).(FleetCertificateConfigurationPtrOutput)
}

// Indicates whether a TLS/SSL certificate is generated for a fleet. Valid values are `DISABLED` and `GENERATED`. Default value is `DISABLED`.
func (o FleetCertificateConfigurationOutput) CertificateType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v FleetCertificateConfiguration) *string { return v.CertificateType }).(pulumi.StringPtrOutput)
}

type FleetCertificateConfigurationPtrOutput struct{ *pulumi.OutputState }

func (FleetCertificateConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**FleetCertificateConfiguration)(nil)).Elem()
}

func (o FleetCertificateConfigurationPtrOutput) ToFleetCertificateConfigurationPtrOutput() FleetCertificateConfigurationPtrOutput {
	return o
}

func (o FleetCertificateConfigurationPtrOutput) ToFleetCertificateConfigurationPtrOutputWithContext(ctx context.Context) FleetCertificateConfigurationPtrOutput {
	return o
}

func (o FleetCertificateConfigurationPtrOutput) Elem() FleetCertificateConfigurationOutput {
	return o.ApplyT(func(v *FleetCertificateConfiguration) FleetCertificateConfiguration {
		if v != nil {
			return *v
		}
		var ret FleetCertificateConfiguration
		return ret
	}).(FleetCertificateConfigurationOutput)
}

// Indicates whether a TLS/SSL certificate is generated for a fleet. Valid values are `DISABLED` and `GENERATED`. Default value is `DISABLED`.
func (o FleetCertificateConfigurationPtrOutput) CertificateType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *FleetCertificateConfiguration) *string {
		if v == nil {
			return nil
		}
		return v.CertificateType
	}).(pulumi.StringPtrOutput)
}

type FleetEc2InboundPermission struct {
	// Starting value for a range of allowed port numbers.
	FromPort int `pulumi:"fromPort"`
	// Range of allowed IP addresses expressed in CIDR notationE.g., `000.000.000.000/[subnet mask]` or `0.0.0.0/[subnet mask]`.
	IpRange string `pulumi:"ipRange"`
	// Network communication protocol used by the fleetE.g., `TCP` or `UDP`
	Protocol string `pulumi:"protocol"`
	// Ending value for a range of allowed port numbers. Port numbers are end-inclusive. This value must be higher than `fromPort`.
	ToPort int `pulumi:"toPort"`
}

// FleetEc2InboundPermissionInput is an input type that accepts FleetEc2InboundPermissionArgs and FleetEc2InboundPermissionOutput values.
// You can construct a concrete instance of `FleetEc2InboundPermissionInput` via:
//
//	FleetEc2InboundPermissionArgs{...}
type FleetEc2InboundPermissionInput interface {
	pulumi.Input

	ToFleetEc2InboundPermissionOutput() FleetEc2InboundPermissionOutput
	ToFleetEc2InboundPermissionOutputWithContext(context.Context) FleetEc2InboundPermissionOutput
}

type FleetEc2InboundPermissionArgs struct {
	// Starting value for a range of allowed port numbers.
	FromPort pulumi.IntInput `pulumi:"fromPort"`
	// Range of allowed IP addresses expressed in CIDR notationE.g., `000.000.000.000/[subnet mask]` or `0.0.0.0/[subnet mask]`.
	IpRange pulumi.StringInput `pulumi:"ipRange"`
	// Network communication protocol used by the fleetE.g., `TCP` or `UDP`
	Protocol pulumi.StringInput `pulumi:"protocol"`
	// Ending value for a range of allowed port numbers. Port numbers are end-inclusive. This value must be higher than `fromPort`.
	ToPort pulumi.IntInput `pulumi:"toPort"`
}

func (FleetEc2InboundPermissionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*FleetEc2InboundPermission)(nil)).Elem()
}

func (i FleetEc2InboundPermissionArgs) ToFleetEc2InboundPermissionOutput() FleetEc2InboundPermissionOutput {
	return i.ToFleetEc2InboundPermissionOutputWithContext(context.Background())
}

func (i FleetEc2InboundPermissionArgs) ToFleetEc2InboundPermissionOutputWithContext(ctx context.Context) FleetEc2InboundPermissionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetEc2InboundPermissionOutput)
}

// FleetEc2InboundPermissionArrayInput is an input type that accepts FleetEc2InboundPermissionArray and FleetEc2InboundPermissionArrayOutput values.
// You can construct a concrete instance of `FleetEc2InboundPermissionArrayInput` via:
//
//	FleetEc2InboundPermissionArray{ FleetEc2InboundPermissionArgs{...} }
type FleetEc2InboundPermissionArrayInput interface {
	pulumi.Input

	ToFleetEc2InboundPermissionArrayOutput() FleetEc2InboundPermissionArrayOutput
	ToFleetEc2InboundPermissionArrayOutputWithContext(context.Context) FleetEc2InboundPermissionArrayOutput
}

type FleetEc2InboundPermissionArray []FleetEc2InboundPermissionInput

func (FleetEc2InboundPermissionArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]FleetEc2InboundPermission)(nil)).Elem()
}

func (i FleetEc2InboundPermissionArray) ToFleetEc2InboundPermissionArrayOutput() FleetEc2InboundPermissionArrayOutput {
	return i.ToFleetEc2InboundPermissionArrayOutputWithContext(context.Background())
}

func (i FleetEc2InboundPermissionArray) ToFleetEc2InboundPermissionArrayOutputWithContext(ctx context.Context) FleetEc2InboundPermissionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetEc2InboundPermissionArrayOutput)
}

type FleetEc2InboundPermissionOutput struct{ *pulumi.OutputState }

func (FleetEc2InboundPermissionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*FleetEc2InboundPermission)(nil)).Elem()
}

func (o FleetEc2InboundPermissionOutput) ToFleetEc2InboundPermissionOutput() FleetEc2InboundPermissionOutput {
	return o
}

func (o FleetEc2InboundPermissionOutput) ToFleetEc2InboundPermissionOutputWithContext(ctx context.Context) FleetEc2InboundPermissionOutput {
	return o
}

// Starting value for a range of allowed port numbers.
func (o FleetEc2InboundPermissionOutput) FromPort() pulumi.IntOutput {
	return o.ApplyT(func(v FleetEc2InboundPermission) int { return v.FromPort }).(pulumi.IntOutput)
}

// Range of allowed IP addresses expressed in CIDR notationE.g., `000.000.000.000/[subnet mask]` or `0.0.0.0/[subnet mask]`.
func (o FleetEc2InboundPermissionOutput) IpRange() pulumi.StringOutput {
	return o.ApplyT(func(v FleetEc2InboundPermission) string { return v.IpRange }).(pulumi.StringOutput)
}

// Network communication protocol used by the fleetE.g., `TCP` or `UDP`
func (o FleetEc2InboundPermissionOutput) Protocol() pulumi.StringOutput {
	return o.ApplyT(func(v FleetEc2InboundPermission) string { return v.Protocol }).(pulumi.StringOutput)
}

// Ending value for a range of allowed port numbers. Port numbers are end-inclusive. This value must be higher than `fromPort`.
func (o FleetEc2InboundPermissionOutput) ToPort() pulumi.IntOutput {
	return o.ApplyT(func(v FleetEc2InboundPermission) int { return v.ToPort }).(pulumi.IntOutput)
}

type FleetEc2InboundPermissionArrayOutput struct{ *pulumi.OutputState }

func (FleetEc2InboundPermissionArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]FleetEc2InboundPermission)(nil)).Elem()
}

func (o FleetEc2InboundPermissionArrayOutput) ToFleetEc2InboundPermissionArrayOutput() FleetEc2InboundPermissionArrayOutput {
	return o
}

func (o FleetEc2InboundPermissionArrayOutput) ToFleetEc2InboundPermissionArrayOutputWithContext(ctx context.Context) FleetEc2InboundPermissionArrayOutput {
	return o
}

func (o FleetEc2InboundPermissionArrayOutput) Index(i pulumi.IntInput) FleetEc2InboundPermissionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) FleetEc2InboundPermission {
		return vs[0].([]FleetEc2InboundPermission)[vs[1].(int)]
	}).(FleetEc2InboundPermissionOutput)
}

type FleetResourceCreationLimitPolicy struct {
	// Maximum number of game sessions that an individual can create during the policy period.
	NewGameSessionsPerCreator *int `pulumi:"newGameSessionsPerCreator"`
	// Time span used in evaluating the resource creation limit policy.
	PolicyPeriodInMinutes *int `pulumi:"policyPeriodInMinutes"`
}

// FleetResourceCreationLimitPolicyInput is an input type that accepts FleetResourceCreationLimitPolicyArgs and FleetResourceCreationLimitPolicyOutput values.
// You can construct a concrete instance of `FleetResourceCreationLimitPolicyInput` via:
//
//	FleetResourceCreationLimitPolicyArgs{...}
type FleetResourceCreationLimitPolicyInput interface {
	pulumi.Input

	ToFleetResourceCreationLimitPolicyOutput() FleetResourceCreationLimitPolicyOutput
	ToFleetResourceCreationLimitPolicyOutputWithContext(context.Context) FleetResourceCreationLimitPolicyOutput
}

type FleetResourceCreationLimitPolicyArgs struct {
	// Maximum number of game sessions that an individual can create during the policy period.
	NewGameSessionsPerCreator pulumi.IntPtrInput `pulumi:"newGameSessionsPerCreator"`
	// Time span used in evaluating the resource creation limit policy.
	PolicyPeriodInMinutes pulumi.IntPtrInput `pulumi:"policyPeriodInMinutes"`
}

func (FleetResourceCreationLimitPolicyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*FleetResourceCreationLimitPolicy)(nil)).Elem()
}

func (i FleetResourceCreationLimitPolicyArgs) ToFleetResourceCreationLimitPolicyOutput() FleetResourceCreationLimitPolicyOutput {
	return i.ToFleetResourceCreationLimitPolicyOutputWithContext(context.Background())
}

func (i FleetResourceCreationLimitPolicyArgs) ToFleetResourceCreationLimitPolicyOutputWithContext(ctx context.Context) FleetResourceCreationLimitPolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetResourceCreationLimitPolicyOutput)
}

func (i FleetResourceCreationLimitPolicyArgs) ToFleetResourceCreationLimitPolicyPtrOutput() FleetResourceCreationLimitPolicyPtrOutput {
	return i.ToFleetResourceCreationLimitPolicyPtrOutputWithContext(context.Background())
}

func (i FleetResourceCreationLimitPolicyArgs) ToFleetResourceCreationLimitPolicyPtrOutputWithContext(ctx context.Context) FleetResourceCreationLimitPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetResourceCreationLimitPolicyOutput).ToFleetResourceCreationLimitPolicyPtrOutputWithContext(ctx)
}

// FleetResourceCreationLimitPolicyPtrInput is an input type that accepts FleetResourceCreationLimitPolicyArgs, FleetResourceCreationLimitPolicyPtr and FleetResourceCreationLimitPolicyPtrOutput values.
// You can construct a concrete instance of `FleetResourceCreationLimitPolicyPtrInput` via:
//
//	        FleetResourceCreationLimitPolicyArgs{...}
//
//	or:
//
//	        nil
type FleetResourceCreationLimitPolicyPtrInput interface {
	pulumi.Input

	ToFleetResourceCreationLimitPolicyPtrOutput() FleetResourceCreationLimitPolicyPtrOutput
	ToFleetResourceCreationLimitPolicyPtrOutputWithContext(context.Context) FleetResourceCreationLimitPolicyPtrOutput
}

type fleetResourceCreationLimitPolicyPtrType FleetResourceCreationLimitPolicyArgs

func FleetResourceCreationLimitPolicyPtr(v *FleetResourceCreationLimitPolicyArgs) FleetResourceCreationLimitPolicyPtrInput {
	return (*fleetResourceCreationLimitPolicyPtrType)(v)
}

func (*fleetResourceCreationLimitPolicyPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**FleetResourceCreationLimitPolicy)(nil)).Elem()
}

func (i *fleetResourceCreationLimitPolicyPtrType) ToFleetResourceCreationLimitPolicyPtrOutput() FleetResourceCreationLimitPolicyPtrOutput {
	return i.ToFleetResourceCreationLimitPolicyPtrOutputWithContext(context.Background())
}

func (i *fleetResourceCreationLimitPolicyPtrType) ToFleetResourceCreationLimitPolicyPtrOutputWithContext(ctx context.Context) FleetResourceCreationLimitPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetResourceCreationLimitPolicyPtrOutput)
}

type FleetResourceCreationLimitPolicyOutput struct{ *pulumi.OutputState }

func (FleetResourceCreationLimitPolicyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*FleetResourceCreationLimitPolicy)(nil)).Elem()
}

func (o FleetResourceCreationLimitPolicyOutput) ToFleetResourceCreationLimitPolicyOutput() FleetResourceCreationLimitPolicyOutput {
	return o
}

func (o FleetResourceCreationLimitPolicyOutput) ToFleetResourceCreationLimitPolicyOutputWithContext(ctx context.Context) FleetResourceCreationLimitPolicyOutput {
	return o
}

func (o FleetResourceCreationLimitPolicyOutput) ToFleetResourceCreationLimitPolicyPtrOutput() FleetResourceCreationLimitPolicyPtrOutput {
	return o.ToFleetResourceCreationLimitPolicyPtrOutputWithContext(context.Background())
}

func (o FleetResourceCreationLimitPolicyOutput) ToFleetResourceCreationLimitPolicyPtrOutputWithContext(ctx context.Context) FleetResourceCreationLimitPolicyPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v FleetResourceCreationLimitPolicy) *FleetResourceCreationLimitPolicy {
		return &v
	}).(FleetResourceCreationLimitPolicyPtrOutput)
}

// Maximum number of game sessions that an individual can create during the policy period.
func (o FleetResourceCreationLimitPolicyOutput) NewGameSessionsPerCreator() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FleetResourceCreationLimitPolicy) *int { return v.NewGameSessionsPerCreator }).(pulumi.IntPtrOutput)
}

// Time span used in evaluating the resource creation limit policy.
func (o FleetResourceCreationLimitPolicyOutput) PolicyPeriodInMinutes() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FleetResourceCreationLimitPolicy) *int { return v.PolicyPeriodInMinutes }).(pulumi.IntPtrOutput)
}

type FleetResourceCreationLimitPolicyPtrOutput struct{ *pulumi.OutputState }

func (FleetResourceCreationLimitPolicyPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**FleetResourceCreationLimitPolicy)(nil)).Elem()
}

func (o FleetResourceCreationLimitPolicyPtrOutput) ToFleetResourceCreationLimitPolicyPtrOutput() FleetResourceCreationLimitPolicyPtrOutput {
	return o
}

func (o FleetResourceCreationLimitPolicyPtrOutput) ToFleetResourceCreationLimitPolicyPtrOutputWithContext(ctx context.Context) FleetResourceCreationLimitPolicyPtrOutput {
	return o
}

func (o FleetResourceCreationLimitPolicyPtrOutput) Elem() FleetResourceCreationLimitPolicyOutput {
	return o.ApplyT(func(v *FleetResourceCreationLimitPolicy) FleetResourceCreationLimitPolicy {
		if v != nil {
			return *v
		}
		var ret FleetResourceCreationLimitPolicy
		return ret
	}).(FleetResourceCreationLimitPolicyOutput)
}

// Maximum number of game sessions that an individual can create during the policy period.
func (o FleetResourceCreationLimitPolicyPtrOutput) NewGameSessionsPerCreator() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *FleetResourceCreationLimitPolicy) *int {
		if v == nil {
			return nil
		}
		return v.NewGameSessionsPerCreator
	}).(pulumi.IntPtrOutput)
}

// Time span used in evaluating the resource creation limit policy.
func (o FleetResourceCreationLimitPolicyPtrOutput) PolicyPeriodInMinutes() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *FleetResourceCreationLimitPolicy) *int {
		if v == nil {
			return nil
		}
		return v.PolicyPeriodInMinutes
	}).(pulumi.IntPtrOutput)
}

type FleetRuntimeConfiguration struct {
	// Maximum amount of time (in seconds) that a game session can remain in status `ACTIVATING`.
	GameSessionActivationTimeoutSeconds *int `pulumi:"gameSessionActivationTimeoutSeconds"`
	// Maximum number of game sessions with status `ACTIVATING` to allow on an instance simultaneously.
	MaxConcurrentGameSessionActivations *int `pulumi:"maxConcurrentGameSessionActivations"`
	// Collection of server process configurations that describe which server processes to run on each instance in a fleet. See below.
	ServerProcesses []FleetRuntimeConfigurationServerProcess `pulumi:"serverProcesses"`
}

// FleetRuntimeConfigurationInput is an input type that accepts FleetRuntimeConfigurationArgs and FleetRuntimeConfigurationOutput values.
// You can construct a concrete instance of `FleetRuntimeConfigurationInput` via:
//
//	FleetRuntimeConfigurationArgs{...}
type FleetRuntimeConfigurationInput interface {
	pulumi.Input

	ToFleetRuntimeConfigurationOutput() FleetRuntimeConfigurationOutput
	ToFleetRuntimeConfigurationOutputWithContext(context.Context) FleetRuntimeConfigurationOutput
}

type FleetRuntimeConfigurationArgs struct {
	// Maximum amount of time (in seconds) that a game session can remain in status `ACTIVATING`.
	GameSessionActivationTimeoutSeconds pulumi.IntPtrInput `pulumi:"gameSessionActivationTimeoutSeconds"`
	// Maximum number of game sessions with status `ACTIVATING` to allow on an instance simultaneously.
	MaxConcurrentGameSessionActivations pulumi.IntPtrInput `pulumi:"maxConcurrentGameSessionActivations"`
	// Collection of server process configurations that describe which server processes to run on each instance in a fleet. See below.
	ServerProcesses FleetRuntimeConfigurationServerProcessArrayInput `pulumi:"serverProcesses"`
}

func (FleetRuntimeConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*FleetRuntimeConfiguration)(nil)).Elem()
}

func (i FleetRuntimeConfigurationArgs) ToFleetRuntimeConfigurationOutput() FleetRuntimeConfigurationOutput {
	return i.ToFleetRuntimeConfigurationOutputWithContext(context.Background())
}

func (i FleetRuntimeConfigurationArgs) ToFleetRuntimeConfigurationOutputWithContext(ctx context.Context) FleetRuntimeConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetRuntimeConfigurationOutput)
}

func (i FleetRuntimeConfigurationArgs) ToFleetRuntimeConfigurationPtrOutput() FleetRuntimeConfigurationPtrOutput {
	return i.ToFleetRuntimeConfigurationPtrOutputWithContext(context.Background())
}

func (i FleetRuntimeConfigurationArgs) ToFleetRuntimeConfigurationPtrOutputWithContext(ctx context.Context) FleetRuntimeConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetRuntimeConfigurationOutput).ToFleetRuntimeConfigurationPtrOutputWithContext(ctx)
}

// FleetRuntimeConfigurationPtrInput is an input type that accepts FleetRuntimeConfigurationArgs, FleetRuntimeConfigurationPtr and FleetRuntimeConfigurationPtrOutput values.
// You can construct a concrete instance of `FleetRuntimeConfigurationPtrInput` via:
//
//	        FleetRuntimeConfigurationArgs{...}
//
//	or:
//
//	        nil
type FleetRuntimeConfigurationPtrInput interface {
	pulumi.Input

	ToFleetRuntimeConfigurationPtrOutput() FleetRuntimeConfigurationPtrOutput
	ToFleetRuntimeConfigurationPtrOutputWithContext(context.Context) FleetRuntimeConfigurationPtrOutput
}

type fleetRuntimeConfigurationPtrType FleetRuntimeConfigurationArgs

func FleetRuntimeConfigurationPtr(v *FleetRuntimeConfigurationArgs) FleetRuntimeConfigurationPtrInput {
	return (*fleetRuntimeConfigurationPtrType)(v)
}

func (*fleetRuntimeConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**FleetRuntimeConfiguration)(nil)).Elem()
}

func (i *fleetRuntimeConfigurationPtrType) ToFleetRuntimeConfigurationPtrOutput() FleetRuntimeConfigurationPtrOutput {
	return i.ToFleetRuntimeConfigurationPtrOutputWithContext(context.Background())
}

func (i *fleetRuntimeConfigurationPtrType) ToFleetRuntimeConfigurationPtrOutputWithContext(ctx context.Context) FleetRuntimeConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetRuntimeConfigurationPtrOutput)
}

type FleetRuntimeConfigurationOutput struct{ *pulumi.OutputState }

func (FleetRuntimeConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*FleetRuntimeConfiguration)(nil)).Elem()
}

func (o FleetRuntimeConfigurationOutput) ToFleetRuntimeConfigurationOutput() FleetRuntimeConfigurationOutput {
	return o
}

func (o FleetRuntimeConfigurationOutput) ToFleetRuntimeConfigurationOutputWithContext(ctx context.Context) FleetRuntimeConfigurationOutput {
	return o
}

func (o FleetRuntimeConfigurationOutput) ToFleetRuntimeConfigurationPtrOutput() FleetRuntimeConfigurationPtrOutput {
	return o.ToFleetRuntimeConfigurationPtrOutputWithContext(context.Background())
}

func (o FleetRuntimeConfigurationOutput) ToFleetRuntimeConfigurationPtrOutputWithContext(ctx context.Context) FleetRuntimeConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v FleetRuntimeConfiguration) *FleetRuntimeConfiguration {
		return &v
	}).(FleetRuntimeConfigurationPtrOutput)
}

// Maximum amount of time (in seconds) that a game session can remain in status `ACTIVATING`.
func (o FleetRuntimeConfigurationOutput) GameSessionActivationTimeoutSeconds() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FleetRuntimeConfiguration) *int { return v.GameSessionActivationTimeoutSeconds }).(pulumi.IntPtrOutput)
}

// Maximum number of game sessions with status `ACTIVATING` to allow on an instance simultaneously.
func (o FleetRuntimeConfigurationOutput) MaxConcurrentGameSessionActivations() pulumi.IntPtrOutput {
	return o.ApplyT(func(v FleetRuntimeConfiguration) *int { return v.MaxConcurrentGameSessionActivations }).(pulumi.IntPtrOutput)
}

// Collection of server process configurations that describe which server processes to run on each instance in a fleet. See below.
func (o FleetRuntimeConfigurationOutput) ServerProcesses() FleetRuntimeConfigurationServerProcessArrayOutput {
	return o.ApplyT(func(v FleetRuntimeConfiguration) []FleetRuntimeConfigurationServerProcess { return v.ServerProcesses }).(FleetRuntimeConfigurationServerProcessArrayOutput)
}

type FleetRuntimeConfigurationPtrOutput struct{ *pulumi.OutputState }

func (FleetRuntimeConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**FleetRuntimeConfiguration)(nil)).Elem()
}

func (o FleetRuntimeConfigurationPtrOutput) ToFleetRuntimeConfigurationPtrOutput() FleetRuntimeConfigurationPtrOutput {
	return o
}

func (o FleetRuntimeConfigurationPtrOutput) ToFleetRuntimeConfigurationPtrOutputWithContext(ctx context.Context) FleetRuntimeConfigurationPtrOutput {
	return o
}

func (o FleetRuntimeConfigurationPtrOutput) Elem() FleetRuntimeConfigurationOutput {
	return o.ApplyT(func(v *FleetRuntimeConfiguration) FleetRuntimeConfiguration {
		if v != nil {
			return *v
		}
		var ret FleetRuntimeConfiguration
		return ret
	}).(FleetRuntimeConfigurationOutput)
}

// Maximum amount of time (in seconds) that a game session can remain in status `ACTIVATING`.
func (o FleetRuntimeConfigurationPtrOutput) GameSessionActivationTimeoutSeconds() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *FleetRuntimeConfiguration) *int {
		if v == nil {
			return nil
		}
		return v.GameSessionActivationTimeoutSeconds
	}).(pulumi.IntPtrOutput)
}

// Maximum number of game sessions with status `ACTIVATING` to allow on an instance simultaneously.
func (o FleetRuntimeConfigurationPtrOutput) MaxConcurrentGameSessionActivations() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *FleetRuntimeConfiguration) *int {
		if v == nil {
			return nil
		}
		return v.MaxConcurrentGameSessionActivations
	}).(pulumi.IntPtrOutput)
}

// Collection of server process configurations that describe which server processes to run on each instance in a fleet. See below.
func (o FleetRuntimeConfigurationPtrOutput) ServerProcesses() FleetRuntimeConfigurationServerProcessArrayOutput {
	return o.ApplyT(func(v *FleetRuntimeConfiguration) []FleetRuntimeConfigurationServerProcess {
		if v == nil {
			return nil
		}
		return v.ServerProcesses
	}).(FleetRuntimeConfigurationServerProcessArrayOutput)
}

type FleetRuntimeConfigurationServerProcess struct {
	// Number of server processes using this configuration to run concurrently on an instance.
	ConcurrentExecutions int `pulumi:"concurrentExecutions"`
	// Location of the server executable in a game build. All game builds are installed on instances at the root : for Windows instances `C:\game`, and for Linux instances `/local/game`.
	LaunchPath string `pulumi:"launchPath"`
	// Optional list of parameters to pass to the server executable on launch.
	Parameters *string `pulumi:"parameters"`
}

// FleetRuntimeConfigurationServerProcessInput is an input type that accepts FleetRuntimeConfigurationServerProcessArgs and FleetRuntimeConfigurationServerProcessOutput values.
// You can construct a concrete instance of `FleetRuntimeConfigurationServerProcessInput` via:
//
//	FleetRuntimeConfigurationServerProcessArgs{...}
type FleetRuntimeConfigurationServerProcessInput interface {
	pulumi.Input

	ToFleetRuntimeConfigurationServerProcessOutput() FleetRuntimeConfigurationServerProcessOutput
	ToFleetRuntimeConfigurationServerProcessOutputWithContext(context.Context) FleetRuntimeConfigurationServerProcessOutput
}

type FleetRuntimeConfigurationServerProcessArgs struct {
	// Number of server processes using this configuration to run concurrently on an instance.
	ConcurrentExecutions pulumi.IntInput `pulumi:"concurrentExecutions"`
	// Location of the server executable in a game build. All game builds are installed on instances at the root : for Windows instances `C:\game`, and for Linux instances `/local/game`.
	LaunchPath pulumi.StringInput `pulumi:"launchPath"`
	// Optional list of parameters to pass to the server executable on launch.
	Parameters pulumi.StringPtrInput `pulumi:"parameters"`
}

func (FleetRuntimeConfigurationServerProcessArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*FleetRuntimeConfigurationServerProcess)(nil)).Elem()
}

func (i FleetRuntimeConfigurationServerProcessArgs) ToFleetRuntimeConfigurationServerProcessOutput() FleetRuntimeConfigurationServerProcessOutput {
	return i.ToFleetRuntimeConfigurationServerProcessOutputWithContext(context.Background())
}

func (i FleetRuntimeConfigurationServerProcessArgs) ToFleetRuntimeConfigurationServerProcessOutputWithContext(ctx context.Context) FleetRuntimeConfigurationServerProcessOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetRuntimeConfigurationServerProcessOutput)
}

// FleetRuntimeConfigurationServerProcessArrayInput is an input type that accepts FleetRuntimeConfigurationServerProcessArray and FleetRuntimeConfigurationServerProcessArrayOutput values.
// You can construct a concrete instance of `FleetRuntimeConfigurationServerProcessArrayInput` via:
//
//	FleetRuntimeConfigurationServerProcessArray{ FleetRuntimeConfigurationServerProcessArgs{...} }
type FleetRuntimeConfigurationServerProcessArrayInput interface {
	pulumi.Input

	ToFleetRuntimeConfigurationServerProcessArrayOutput() FleetRuntimeConfigurationServerProcessArrayOutput
	ToFleetRuntimeConfigurationServerProcessArrayOutputWithContext(context.Context) FleetRuntimeConfigurationServerProcessArrayOutput
}

type FleetRuntimeConfigurationServerProcessArray []FleetRuntimeConfigurationServerProcessInput

func (FleetRuntimeConfigurationServerProcessArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]FleetRuntimeConfigurationServerProcess)(nil)).Elem()
}

func (i FleetRuntimeConfigurationServerProcessArray) ToFleetRuntimeConfigurationServerProcessArrayOutput() FleetRuntimeConfigurationServerProcessArrayOutput {
	return i.ToFleetRuntimeConfigurationServerProcessArrayOutputWithContext(context.Background())
}

func (i FleetRuntimeConfigurationServerProcessArray) ToFleetRuntimeConfigurationServerProcessArrayOutputWithContext(ctx context.Context) FleetRuntimeConfigurationServerProcessArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(FleetRuntimeConfigurationServerProcessArrayOutput)
}

type FleetRuntimeConfigurationServerProcessOutput struct{ *pulumi.OutputState }

func (FleetRuntimeConfigurationServerProcessOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*FleetRuntimeConfigurationServerProcess)(nil)).Elem()
}

func (o FleetRuntimeConfigurationServerProcessOutput) ToFleetRuntimeConfigurationServerProcessOutput() FleetRuntimeConfigurationServerProcessOutput {
	return o
}

func (o FleetRuntimeConfigurationServerProcessOutput) ToFleetRuntimeConfigurationServerProcessOutputWithContext(ctx context.Context) FleetRuntimeConfigurationServerProcessOutput {
	return o
}

// Number of server processes using this configuration to run concurrently on an instance.
func (o FleetRuntimeConfigurationServerProcessOutput) ConcurrentExecutions() pulumi.IntOutput {
	return o.ApplyT(func(v FleetRuntimeConfigurationServerProcess) int { return v.ConcurrentExecutions }).(pulumi.IntOutput)
}

// Location of the server executable in a game build. All game builds are installed on instances at the root : for Windows instances `C:\game`, and for Linux instances `/local/game`.
func (o FleetRuntimeConfigurationServerProcessOutput) LaunchPath() pulumi.StringOutput {
	return o.ApplyT(func(v FleetRuntimeConfigurationServerProcess) string { return v.LaunchPath }).(pulumi.StringOutput)
}

// Optional list of parameters to pass to the server executable on launch.
func (o FleetRuntimeConfigurationServerProcessOutput) Parameters() pulumi.StringPtrOutput {
	return o.ApplyT(func(v FleetRuntimeConfigurationServerProcess) *string { return v.Parameters }).(pulumi.StringPtrOutput)
}

type FleetRuntimeConfigurationServerProcessArrayOutput struct{ *pulumi.OutputState }

func (FleetRuntimeConfigurationServerProcessArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]FleetRuntimeConfigurationServerProcess)(nil)).Elem()
}

func (o FleetRuntimeConfigurationServerProcessArrayOutput) ToFleetRuntimeConfigurationServerProcessArrayOutput() FleetRuntimeConfigurationServerProcessArrayOutput {
	return o
}

func (o FleetRuntimeConfigurationServerProcessArrayOutput) ToFleetRuntimeConfigurationServerProcessArrayOutputWithContext(ctx context.Context) FleetRuntimeConfigurationServerProcessArrayOutput {
	return o
}

func (o FleetRuntimeConfigurationServerProcessArrayOutput) Index(i pulumi.IntInput) FleetRuntimeConfigurationServerProcessOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) FleetRuntimeConfigurationServerProcess {
		return vs[0].([]FleetRuntimeConfigurationServerProcess)[vs[1].(int)]
	}).(FleetRuntimeConfigurationServerProcessOutput)
}

type GameServerGroupAutoScalingPolicy struct {
	// Length of time, in seconds, it takes for a new instance to start
	// new game server processes and register with GameLift FleetIQ.
	// Specifying a warm-up time can be useful, particularly with game servers that take a long time to start up,
	// because it avoids prematurely starting new instances. Defaults to `60`.
	EstimatedInstanceWarmup     *int                                                        `pulumi:"estimatedInstanceWarmup"`
	TargetTrackingConfiguration GameServerGroupAutoScalingPolicyTargetTrackingConfiguration `pulumi:"targetTrackingConfiguration"`
}

// GameServerGroupAutoScalingPolicyInput is an input type that accepts GameServerGroupAutoScalingPolicyArgs and GameServerGroupAutoScalingPolicyOutput values.
// You can construct a concrete instance of `GameServerGroupAutoScalingPolicyInput` via:
//
//	GameServerGroupAutoScalingPolicyArgs{...}
type GameServerGroupAutoScalingPolicyInput interface {
	pulumi.Input

	ToGameServerGroupAutoScalingPolicyOutput() GameServerGroupAutoScalingPolicyOutput
	ToGameServerGroupAutoScalingPolicyOutputWithContext(context.Context) GameServerGroupAutoScalingPolicyOutput
}

type GameServerGroupAutoScalingPolicyArgs struct {
	// Length of time, in seconds, it takes for a new instance to start
	// new game server processes and register with GameLift FleetIQ.
	// Specifying a warm-up time can be useful, particularly with game servers that take a long time to start up,
	// because it avoids prematurely starting new instances. Defaults to `60`.
	EstimatedInstanceWarmup     pulumi.IntPtrInput                                               `pulumi:"estimatedInstanceWarmup"`
	TargetTrackingConfiguration GameServerGroupAutoScalingPolicyTargetTrackingConfigurationInput `pulumi:"targetTrackingConfiguration"`
}

func (GameServerGroupAutoScalingPolicyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GameServerGroupAutoScalingPolicy)(nil)).Elem()
}

func (i GameServerGroupAutoScalingPolicyArgs) ToGameServerGroupAutoScalingPolicyOutput() GameServerGroupAutoScalingPolicyOutput {
	return i.ToGameServerGroupAutoScalingPolicyOutputWithContext(context.Background())
}

func (i GameServerGroupAutoScalingPolicyArgs) ToGameServerGroupAutoScalingPolicyOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameServerGroupAutoScalingPolicyOutput)
}

func (i GameServerGroupAutoScalingPolicyArgs) ToGameServerGroupAutoScalingPolicyPtrOutput() GameServerGroupAutoScalingPolicyPtrOutput {
	return i.ToGameServerGroupAutoScalingPolicyPtrOutputWithContext(context.Background())
}

func (i GameServerGroupAutoScalingPolicyArgs) ToGameServerGroupAutoScalingPolicyPtrOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameServerGroupAutoScalingPolicyOutput).ToGameServerGroupAutoScalingPolicyPtrOutputWithContext(ctx)
}

// GameServerGroupAutoScalingPolicyPtrInput is an input type that accepts GameServerGroupAutoScalingPolicyArgs, GameServerGroupAutoScalingPolicyPtr and GameServerGroupAutoScalingPolicyPtrOutput values.
// You can construct a concrete instance of `GameServerGroupAutoScalingPolicyPtrInput` via:
//
//	        GameServerGroupAutoScalingPolicyArgs{...}
//
//	or:
//
//	        nil
type GameServerGroupAutoScalingPolicyPtrInput interface {
	pulumi.Input

	ToGameServerGroupAutoScalingPolicyPtrOutput() GameServerGroupAutoScalingPolicyPtrOutput
	ToGameServerGroupAutoScalingPolicyPtrOutputWithContext(context.Context) GameServerGroupAutoScalingPolicyPtrOutput
}

type gameServerGroupAutoScalingPolicyPtrType GameServerGroupAutoScalingPolicyArgs

func GameServerGroupAutoScalingPolicyPtr(v *GameServerGroupAutoScalingPolicyArgs) GameServerGroupAutoScalingPolicyPtrInput {
	return (*gameServerGroupAutoScalingPolicyPtrType)(v)
}

func (*gameServerGroupAutoScalingPolicyPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GameServerGroupAutoScalingPolicy)(nil)).Elem()
}

func (i *gameServerGroupAutoScalingPolicyPtrType) ToGameServerGroupAutoScalingPolicyPtrOutput() GameServerGroupAutoScalingPolicyPtrOutput {
	return i.ToGameServerGroupAutoScalingPolicyPtrOutputWithContext(context.Background())
}

func (i *gameServerGroupAutoScalingPolicyPtrType) ToGameServerGroupAutoScalingPolicyPtrOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameServerGroupAutoScalingPolicyPtrOutput)
}

type GameServerGroupAutoScalingPolicyOutput struct{ *pulumi.OutputState }

func (GameServerGroupAutoScalingPolicyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GameServerGroupAutoScalingPolicy)(nil)).Elem()
}

func (o GameServerGroupAutoScalingPolicyOutput) ToGameServerGroupAutoScalingPolicyOutput() GameServerGroupAutoScalingPolicyOutput {
	return o
}

func (o GameServerGroupAutoScalingPolicyOutput) ToGameServerGroupAutoScalingPolicyOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyOutput {
	return o
}

func (o GameServerGroupAutoScalingPolicyOutput) ToGameServerGroupAutoScalingPolicyPtrOutput() GameServerGroupAutoScalingPolicyPtrOutput {
	return o.ToGameServerGroupAutoScalingPolicyPtrOutputWithContext(context.Background())
}

func (o GameServerGroupAutoScalingPolicyOutput) ToGameServerGroupAutoScalingPolicyPtrOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GameServerGroupAutoScalingPolicy) *GameServerGroupAutoScalingPolicy {
		return &v
	}).(GameServerGroupAutoScalingPolicyPtrOutput)
}

// Length of time, in seconds, it takes for a new instance to start
// new game server processes and register with GameLift FleetIQ.
// Specifying a warm-up time can be useful, particularly with game servers that take a long time to start up,
// because it avoids prematurely starting new instances. Defaults to `60`.
func (o GameServerGroupAutoScalingPolicyOutput) EstimatedInstanceWarmup() pulumi.IntPtrOutput {
	return o.ApplyT(func(v GameServerGroupAutoScalingPolicy) *int { return v.EstimatedInstanceWarmup }).(pulumi.IntPtrOutput)
}

func (o GameServerGroupAutoScalingPolicyOutput) TargetTrackingConfiguration() GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput {
	return o.ApplyT(func(v GameServerGroupAutoScalingPolicy) GameServerGroupAutoScalingPolicyTargetTrackingConfiguration {
		return v.TargetTrackingConfiguration
	}).(GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput)
}

type GameServerGroupAutoScalingPolicyPtrOutput struct{ *pulumi.OutputState }

func (GameServerGroupAutoScalingPolicyPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GameServerGroupAutoScalingPolicy)(nil)).Elem()
}

func (o GameServerGroupAutoScalingPolicyPtrOutput) ToGameServerGroupAutoScalingPolicyPtrOutput() GameServerGroupAutoScalingPolicyPtrOutput {
	return o
}

func (o GameServerGroupAutoScalingPolicyPtrOutput) ToGameServerGroupAutoScalingPolicyPtrOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyPtrOutput {
	return o
}

func (o GameServerGroupAutoScalingPolicyPtrOutput) Elem() GameServerGroupAutoScalingPolicyOutput {
	return o.ApplyT(func(v *GameServerGroupAutoScalingPolicy) GameServerGroupAutoScalingPolicy {
		if v != nil {
			return *v
		}
		var ret GameServerGroupAutoScalingPolicy
		return ret
	}).(GameServerGroupAutoScalingPolicyOutput)
}

// Length of time, in seconds, it takes for a new instance to start
// new game server processes and register with GameLift FleetIQ.
// Specifying a warm-up time can be useful, particularly with game servers that take a long time to start up,
// because it avoids prematurely starting new instances. Defaults to `60`.
func (o GameServerGroupAutoScalingPolicyPtrOutput) EstimatedInstanceWarmup() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *GameServerGroupAutoScalingPolicy) *int {
		if v == nil {
			return nil
		}
		return v.EstimatedInstanceWarmup
	}).(pulumi.IntPtrOutput)
}

func (o GameServerGroupAutoScalingPolicyPtrOutput) TargetTrackingConfiguration() GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput {
	return o.ApplyT(func(v *GameServerGroupAutoScalingPolicy) *GameServerGroupAutoScalingPolicyTargetTrackingConfiguration {
		if v == nil {
			return nil
		}
		return &v.TargetTrackingConfiguration
	}).(GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput)
}

type GameServerGroupAutoScalingPolicyTargetTrackingConfiguration struct {
	// Desired value to use with a game server group target-based scaling policy.
	TargetValue float64 `pulumi:"targetValue"`
}

// GameServerGroupAutoScalingPolicyTargetTrackingConfigurationInput is an input type that accepts GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs and GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput values.
// You can construct a concrete instance of `GameServerGroupAutoScalingPolicyTargetTrackingConfigurationInput` via:
//
//	GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs{...}
type GameServerGroupAutoScalingPolicyTargetTrackingConfigurationInput interface {
	pulumi.Input

	ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput() GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput
	ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutputWithContext(context.Context) GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput
}

type GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs struct {
	// Desired value to use with a game server group target-based scaling policy.
	TargetValue pulumi.Float64Input `pulumi:"targetValue"`
}

func (GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GameServerGroupAutoScalingPolicyTargetTrackingConfiguration)(nil)).Elem()
}

func (i GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput() GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput {
	return i.ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutputWithContext(context.Background())
}

func (i GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput)
}

func (i GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput() GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput {
	return i.ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutputWithContext(context.Background())
}

func (i GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput).ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutputWithContext(ctx)
}

// GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrInput is an input type that accepts GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs, GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtr and GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput values.
// You can construct a concrete instance of `GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrInput` via:
//
//	        GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs{...}
//
//	or:
//
//	        nil
type GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrInput interface {
	pulumi.Input

	ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput() GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput
	ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutputWithContext(context.Context) GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput
}

type gameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrType GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs

func GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtr(v *GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs) GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrInput {
	return (*gameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrType)(v)
}

func (*gameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GameServerGroupAutoScalingPolicyTargetTrackingConfiguration)(nil)).Elem()
}

func (i *gameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrType) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput() GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput {
	return i.ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutputWithContext(context.Background())
}

func (i *gameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrType) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput)
}

type GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput struct{ *pulumi.OutputState }

func (GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GameServerGroupAutoScalingPolicyTargetTrackingConfiguration)(nil)).Elem()
}

func (o GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput() GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput {
	return o
}

func (o GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput {
	return o
}

func (o GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput() GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput {
	return o.ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutputWithContext(context.Background())
}

func (o GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GameServerGroupAutoScalingPolicyTargetTrackingConfiguration) *GameServerGroupAutoScalingPolicyTargetTrackingConfiguration {
		return &v
	}).(GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput)
}

// Desired value to use with a game server group target-based scaling policy.
func (o GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput) TargetValue() pulumi.Float64Output {
	return o.ApplyT(func(v GameServerGroupAutoScalingPolicyTargetTrackingConfiguration) float64 { return v.TargetValue }).(pulumi.Float64Output)
}

type GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput struct{ *pulumi.OutputState }

func (GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GameServerGroupAutoScalingPolicyTargetTrackingConfiguration)(nil)).Elem()
}

func (o GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput() GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput {
	return o
}

func (o GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput) ToGameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutputWithContext(ctx context.Context) GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput {
	return o
}

func (o GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput) Elem() GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput {
	return o.ApplyT(func(v *GameServerGroupAutoScalingPolicyTargetTrackingConfiguration) GameServerGroupAutoScalingPolicyTargetTrackingConfiguration {
		if v != nil {
			return *v
		}
		var ret GameServerGroupAutoScalingPolicyTargetTrackingConfiguration
		return ret
	}).(GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput)
}

// Desired value to use with a game server group target-based scaling policy.
func (o GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput) TargetValue() pulumi.Float64PtrOutput {
	return o.ApplyT(func(v *GameServerGroupAutoScalingPolicyTargetTrackingConfiguration) *float64 {
		if v == nil {
			return nil
		}
		return &v.TargetValue
	}).(pulumi.Float64PtrOutput)
}

type GameServerGroupInstanceDefinition struct {
	// An EC2 instance type.
	InstanceType string `pulumi:"instanceType"`
	// Instance weighting that indicates how much this instance type contributes
	// to the total capacity of a game server group.
	// Instance weights are used by GameLift FleetIQ to calculate the instance type's cost per unit hour and better identify
	// the most cost-effective options.
	WeightedCapacity *string `pulumi:"weightedCapacity"`
}

// GameServerGroupInstanceDefinitionInput is an input type that accepts GameServerGroupInstanceDefinitionArgs and GameServerGroupInstanceDefinitionOutput values.
// You can construct a concrete instance of `GameServerGroupInstanceDefinitionInput` via:
//
//	GameServerGroupInstanceDefinitionArgs{...}
type GameServerGroupInstanceDefinitionInput interface {
	pulumi.Input

	ToGameServerGroupInstanceDefinitionOutput() GameServerGroupInstanceDefinitionOutput
	ToGameServerGroupInstanceDefinitionOutputWithContext(context.Context) GameServerGroupInstanceDefinitionOutput
}

type GameServerGroupInstanceDefinitionArgs struct {
	// An EC2 instance type.
	InstanceType pulumi.StringInput `pulumi:"instanceType"`
	// Instance weighting that indicates how much this instance type contributes
	// to the total capacity of a game server group.
	// Instance weights are used by GameLift FleetIQ to calculate the instance type's cost per unit hour and better identify
	// the most cost-effective options.
	WeightedCapacity pulumi.StringPtrInput `pulumi:"weightedCapacity"`
}

func (GameServerGroupInstanceDefinitionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GameServerGroupInstanceDefinition)(nil)).Elem()
}

func (i GameServerGroupInstanceDefinitionArgs) ToGameServerGroupInstanceDefinitionOutput() GameServerGroupInstanceDefinitionOutput {
	return i.ToGameServerGroupInstanceDefinitionOutputWithContext(context.Background())
}

func (i GameServerGroupInstanceDefinitionArgs) ToGameServerGroupInstanceDefinitionOutputWithContext(ctx context.Context) GameServerGroupInstanceDefinitionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameServerGroupInstanceDefinitionOutput)
}

// GameServerGroupInstanceDefinitionArrayInput is an input type that accepts GameServerGroupInstanceDefinitionArray and GameServerGroupInstanceDefinitionArrayOutput values.
// You can construct a concrete instance of `GameServerGroupInstanceDefinitionArrayInput` via:
//
//	GameServerGroupInstanceDefinitionArray{ GameServerGroupInstanceDefinitionArgs{...} }
type GameServerGroupInstanceDefinitionArrayInput interface {
	pulumi.Input

	ToGameServerGroupInstanceDefinitionArrayOutput() GameServerGroupInstanceDefinitionArrayOutput
	ToGameServerGroupInstanceDefinitionArrayOutputWithContext(context.Context) GameServerGroupInstanceDefinitionArrayOutput
}

type GameServerGroupInstanceDefinitionArray []GameServerGroupInstanceDefinitionInput

func (GameServerGroupInstanceDefinitionArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GameServerGroupInstanceDefinition)(nil)).Elem()
}

func (i GameServerGroupInstanceDefinitionArray) ToGameServerGroupInstanceDefinitionArrayOutput() GameServerGroupInstanceDefinitionArrayOutput {
	return i.ToGameServerGroupInstanceDefinitionArrayOutputWithContext(context.Background())
}

func (i GameServerGroupInstanceDefinitionArray) ToGameServerGroupInstanceDefinitionArrayOutputWithContext(ctx context.Context) GameServerGroupInstanceDefinitionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameServerGroupInstanceDefinitionArrayOutput)
}

type GameServerGroupInstanceDefinitionOutput struct{ *pulumi.OutputState }

func (GameServerGroupInstanceDefinitionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GameServerGroupInstanceDefinition)(nil)).Elem()
}

func (o GameServerGroupInstanceDefinitionOutput) ToGameServerGroupInstanceDefinitionOutput() GameServerGroupInstanceDefinitionOutput {
	return o
}

func (o GameServerGroupInstanceDefinitionOutput) ToGameServerGroupInstanceDefinitionOutputWithContext(ctx context.Context) GameServerGroupInstanceDefinitionOutput {
	return o
}

// An EC2 instance type.
func (o GameServerGroupInstanceDefinitionOutput) InstanceType() pulumi.StringOutput {
	return o.ApplyT(func(v GameServerGroupInstanceDefinition) string { return v.InstanceType }).(pulumi.StringOutput)
}

// Instance weighting that indicates how much this instance type contributes
// to the total capacity of a game server group.
// Instance weights are used by GameLift FleetIQ to calculate the instance type's cost per unit hour and better identify
// the most cost-effective options.
func (o GameServerGroupInstanceDefinitionOutput) WeightedCapacity() pulumi.StringPtrOutput {
	return o.ApplyT(func(v GameServerGroupInstanceDefinition) *string { return v.WeightedCapacity }).(pulumi.StringPtrOutput)
}

type GameServerGroupInstanceDefinitionArrayOutput struct{ *pulumi.OutputState }

func (GameServerGroupInstanceDefinitionArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GameServerGroupInstanceDefinition)(nil)).Elem()
}

func (o GameServerGroupInstanceDefinitionArrayOutput) ToGameServerGroupInstanceDefinitionArrayOutput() GameServerGroupInstanceDefinitionArrayOutput {
	return o
}

func (o GameServerGroupInstanceDefinitionArrayOutput) ToGameServerGroupInstanceDefinitionArrayOutputWithContext(ctx context.Context) GameServerGroupInstanceDefinitionArrayOutput {
	return o
}

func (o GameServerGroupInstanceDefinitionArrayOutput) Index(i pulumi.IntInput) GameServerGroupInstanceDefinitionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GameServerGroupInstanceDefinition {
		return vs[0].([]GameServerGroupInstanceDefinition)[vs[1].(int)]
	}).(GameServerGroupInstanceDefinitionOutput)
}

type GameServerGroupLaunchTemplate struct {
	// A unique identifier for an existing EC2 launch template.
	Id *string `pulumi:"id"`
	// A readable identifier for an existing EC2 launch template.
	Name *string `pulumi:"name"`
	// The version of the EC2 launch template to use. If none is set, the default is the first version created.
	Version *string `pulumi:"version"`
}

// GameServerGroupLaunchTemplateInput is an input type that accepts GameServerGroupLaunchTemplateArgs and GameServerGroupLaunchTemplateOutput values.
// You can construct a concrete instance of `GameServerGroupLaunchTemplateInput` via:
//
//	GameServerGroupLaunchTemplateArgs{...}
type GameServerGroupLaunchTemplateInput interface {
	pulumi.Input

	ToGameServerGroupLaunchTemplateOutput() GameServerGroupLaunchTemplateOutput
	ToGameServerGroupLaunchTemplateOutputWithContext(context.Context) GameServerGroupLaunchTemplateOutput
}

type GameServerGroupLaunchTemplateArgs struct {
	// A unique identifier for an existing EC2 launch template.
	Id pulumi.StringPtrInput `pulumi:"id"`
	// A readable identifier for an existing EC2 launch template.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The version of the EC2 launch template to use. If none is set, the default is the first version created.
	Version pulumi.StringPtrInput `pulumi:"version"`
}

func (GameServerGroupLaunchTemplateArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GameServerGroupLaunchTemplate)(nil)).Elem()
}

func (i GameServerGroupLaunchTemplateArgs) ToGameServerGroupLaunchTemplateOutput() GameServerGroupLaunchTemplateOutput {
	return i.ToGameServerGroupLaunchTemplateOutputWithContext(context.Background())
}

func (i GameServerGroupLaunchTemplateArgs) ToGameServerGroupLaunchTemplateOutputWithContext(ctx context.Context) GameServerGroupLaunchTemplateOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameServerGroupLaunchTemplateOutput)
}

func (i GameServerGroupLaunchTemplateArgs) ToGameServerGroupLaunchTemplatePtrOutput() GameServerGroupLaunchTemplatePtrOutput {
	return i.ToGameServerGroupLaunchTemplatePtrOutputWithContext(context.Background())
}

func (i GameServerGroupLaunchTemplateArgs) ToGameServerGroupLaunchTemplatePtrOutputWithContext(ctx context.Context) GameServerGroupLaunchTemplatePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameServerGroupLaunchTemplateOutput).ToGameServerGroupLaunchTemplatePtrOutputWithContext(ctx)
}

// GameServerGroupLaunchTemplatePtrInput is an input type that accepts GameServerGroupLaunchTemplateArgs, GameServerGroupLaunchTemplatePtr and GameServerGroupLaunchTemplatePtrOutput values.
// You can construct a concrete instance of `GameServerGroupLaunchTemplatePtrInput` via:
//
//	        GameServerGroupLaunchTemplateArgs{...}
//
//	or:
//
//	        nil
type GameServerGroupLaunchTemplatePtrInput interface {
	pulumi.Input

	ToGameServerGroupLaunchTemplatePtrOutput() GameServerGroupLaunchTemplatePtrOutput
	ToGameServerGroupLaunchTemplatePtrOutputWithContext(context.Context) GameServerGroupLaunchTemplatePtrOutput
}

type gameServerGroupLaunchTemplatePtrType GameServerGroupLaunchTemplateArgs

func GameServerGroupLaunchTemplatePtr(v *GameServerGroupLaunchTemplateArgs) GameServerGroupLaunchTemplatePtrInput {
	return (*gameServerGroupLaunchTemplatePtrType)(v)
}

func (*gameServerGroupLaunchTemplatePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GameServerGroupLaunchTemplate)(nil)).Elem()
}

func (i *gameServerGroupLaunchTemplatePtrType) ToGameServerGroupLaunchTemplatePtrOutput() GameServerGroupLaunchTemplatePtrOutput {
	return i.ToGameServerGroupLaunchTemplatePtrOutputWithContext(context.Background())
}

func (i *gameServerGroupLaunchTemplatePtrType) ToGameServerGroupLaunchTemplatePtrOutputWithContext(ctx context.Context) GameServerGroupLaunchTemplatePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameServerGroupLaunchTemplatePtrOutput)
}

type GameServerGroupLaunchTemplateOutput struct{ *pulumi.OutputState }

func (GameServerGroupLaunchTemplateOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GameServerGroupLaunchTemplate)(nil)).Elem()
}

func (o GameServerGroupLaunchTemplateOutput) ToGameServerGroupLaunchTemplateOutput() GameServerGroupLaunchTemplateOutput {
	return o
}

func (o GameServerGroupLaunchTemplateOutput) ToGameServerGroupLaunchTemplateOutputWithContext(ctx context.Context) GameServerGroupLaunchTemplateOutput {
	return o
}

func (o GameServerGroupLaunchTemplateOutput) ToGameServerGroupLaunchTemplatePtrOutput() GameServerGroupLaunchTemplatePtrOutput {
	return o.ToGameServerGroupLaunchTemplatePtrOutputWithContext(context.Background())
}

func (o GameServerGroupLaunchTemplateOutput) ToGameServerGroupLaunchTemplatePtrOutputWithContext(ctx context.Context) GameServerGroupLaunchTemplatePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GameServerGroupLaunchTemplate) *GameServerGroupLaunchTemplate {
		return &v
	}).(GameServerGroupLaunchTemplatePtrOutput)
}

// A unique identifier for an existing EC2 launch template.
func (o GameServerGroupLaunchTemplateOutput) Id() pulumi.StringPtrOutput {
	return o.ApplyT(func(v GameServerGroupLaunchTemplate) *string { return v.Id }).(pulumi.StringPtrOutput)
}

// A readable identifier for an existing EC2 launch template.
func (o GameServerGroupLaunchTemplateOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v GameServerGroupLaunchTemplate) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// The version of the EC2 launch template to use. If none is set, the default is the first version created.
func (o GameServerGroupLaunchTemplateOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v GameServerGroupLaunchTemplate) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type GameServerGroupLaunchTemplatePtrOutput struct{ *pulumi.OutputState }

func (GameServerGroupLaunchTemplatePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GameServerGroupLaunchTemplate)(nil)).Elem()
}

func (o GameServerGroupLaunchTemplatePtrOutput) ToGameServerGroupLaunchTemplatePtrOutput() GameServerGroupLaunchTemplatePtrOutput {
	return o
}

func (o GameServerGroupLaunchTemplatePtrOutput) ToGameServerGroupLaunchTemplatePtrOutputWithContext(ctx context.Context) GameServerGroupLaunchTemplatePtrOutput {
	return o
}

func (o GameServerGroupLaunchTemplatePtrOutput) Elem() GameServerGroupLaunchTemplateOutput {
	return o.ApplyT(func(v *GameServerGroupLaunchTemplate) GameServerGroupLaunchTemplate {
		if v != nil {
			return *v
		}
		var ret GameServerGroupLaunchTemplate
		return ret
	}).(GameServerGroupLaunchTemplateOutput)
}

// A unique identifier for an existing EC2 launch template.
func (o GameServerGroupLaunchTemplatePtrOutput) Id() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GameServerGroupLaunchTemplate) *string {
		if v == nil {
			return nil
		}
		return v.Id
	}).(pulumi.StringPtrOutput)
}

// A readable identifier for an existing EC2 launch template.
func (o GameServerGroupLaunchTemplatePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GameServerGroupLaunchTemplate) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// The version of the EC2 launch template to use. If none is set, the default is the first version created.
func (o GameServerGroupLaunchTemplatePtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GameServerGroupLaunchTemplate) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

type GameSessionQueuePlayerLatencyPolicy struct {
	// Maximum latency value that is allowed for any player.
	MaximumIndividualPlayerLatencyMilliseconds int `pulumi:"maximumIndividualPlayerLatencyMilliseconds"`
	// Length of time that the policy is enforced while placing a new game session. Absence of value for this attribute means that the policy is enforced until the queue times out.
	PolicyDurationSeconds *int `pulumi:"policyDurationSeconds"`
}

// GameSessionQueuePlayerLatencyPolicyInput is an input type that accepts GameSessionQueuePlayerLatencyPolicyArgs and GameSessionQueuePlayerLatencyPolicyOutput values.
// You can construct a concrete instance of `GameSessionQueuePlayerLatencyPolicyInput` via:
//
//	GameSessionQueuePlayerLatencyPolicyArgs{...}
type GameSessionQueuePlayerLatencyPolicyInput interface {
	pulumi.Input

	ToGameSessionQueuePlayerLatencyPolicyOutput() GameSessionQueuePlayerLatencyPolicyOutput
	ToGameSessionQueuePlayerLatencyPolicyOutputWithContext(context.Context) GameSessionQueuePlayerLatencyPolicyOutput
}

type GameSessionQueuePlayerLatencyPolicyArgs struct {
	// Maximum latency value that is allowed for any player.
	MaximumIndividualPlayerLatencyMilliseconds pulumi.IntInput `pulumi:"maximumIndividualPlayerLatencyMilliseconds"`
	// Length of time that the policy is enforced while placing a new game session. Absence of value for this attribute means that the policy is enforced until the queue times out.
	PolicyDurationSeconds pulumi.IntPtrInput `pulumi:"policyDurationSeconds"`
}

func (GameSessionQueuePlayerLatencyPolicyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GameSessionQueuePlayerLatencyPolicy)(nil)).Elem()
}

func (i GameSessionQueuePlayerLatencyPolicyArgs) ToGameSessionQueuePlayerLatencyPolicyOutput() GameSessionQueuePlayerLatencyPolicyOutput {
	return i.ToGameSessionQueuePlayerLatencyPolicyOutputWithContext(context.Background())
}

func (i GameSessionQueuePlayerLatencyPolicyArgs) ToGameSessionQueuePlayerLatencyPolicyOutputWithContext(ctx context.Context) GameSessionQueuePlayerLatencyPolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameSessionQueuePlayerLatencyPolicyOutput)
}

// GameSessionQueuePlayerLatencyPolicyArrayInput is an input type that accepts GameSessionQueuePlayerLatencyPolicyArray and GameSessionQueuePlayerLatencyPolicyArrayOutput values.
// You can construct a concrete instance of `GameSessionQueuePlayerLatencyPolicyArrayInput` via:
//
//	GameSessionQueuePlayerLatencyPolicyArray{ GameSessionQueuePlayerLatencyPolicyArgs{...} }
type GameSessionQueuePlayerLatencyPolicyArrayInput interface {
	pulumi.Input

	ToGameSessionQueuePlayerLatencyPolicyArrayOutput() GameSessionQueuePlayerLatencyPolicyArrayOutput
	ToGameSessionQueuePlayerLatencyPolicyArrayOutputWithContext(context.Context) GameSessionQueuePlayerLatencyPolicyArrayOutput
}

type GameSessionQueuePlayerLatencyPolicyArray []GameSessionQueuePlayerLatencyPolicyInput

func (GameSessionQueuePlayerLatencyPolicyArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GameSessionQueuePlayerLatencyPolicy)(nil)).Elem()
}

func (i GameSessionQueuePlayerLatencyPolicyArray) ToGameSessionQueuePlayerLatencyPolicyArrayOutput() GameSessionQueuePlayerLatencyPolicyArrayOutput {
	return i.ToGameSessionQueuePlayerLatencyPolicyArrayOutputWithContext(context.Background())
}

func (i GameSessionQueuePlayerLatencyPolicyArray) ToGameSessionQueuePlayerLatencyPolicyArrayOutputWithContext(ctx context.Context) GameSessionQueuePlayerLatencyPolicyArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GameSessionQueuePlayerLatencyPolicyArrayOutput)
}

type GameSessionQueuePlayerLatencyPolicyOutput struct{ *pulumi.OutputState }

func (GameSessionQueuePlayerLatencyPolicyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GameSessionQueuePlayerLatencyPolicy)(nil)).Elem()
}

func (o GameSessionQueuePlayerLatencyPolicyOutput) ToGameSessionQueuePlayerLatencyPolicyOutput() GameSessionQueuePlayerLatencyPolicyOutput {
	return o
}

func (o GameSessionQueuePlayerLatencyPolicyOutput) ToGameSessionQueuePlayerLatencyPolicyOutputWithContext(ctx context.Context) GameSessionQueuePlayerLatencyPolicyOutput {
	return o
}

// Maximum latency value that is allowed for any player.
func (o GameSessionQueuePlayerLatencyPolicyOutput) MaximumIndividualPlayerLatencyMilliseconds() pulumi.IntOutput {
	return o.ApplyT(func(v GameSessionQueuePlayerLatencyPolicy) int { return v.MaximumIndividualPlayerLatencyMilliseconds }).(pulumi.IntOutput)
}

// Length of time that the policy is enforced while placing a new game session. Absence of value for this attribute means that the policy is enforced until the queue times out.
func (o GameSessionQueuePlayerLatencyPolicyOutput) PolicyDurationSeconds() pulumi.IntPtrOutput {
	return o.ApplyT(func(v GameSessionQueuePlayerLatencyPolicy) *int { return v.PolicyDurationSeconds }).(pulumi.IntPtrOutput)
}

type GameSessionQueuePlayerLatencyPolicyArrayOutput struct{ *pulumi.OutputState }

func (GameSessionQueuePlayerLatencyPolicyArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GameSessionQueuePlayerLatencyPolicy)(nil)).Elem()
}

func (o GameSessionQueuePlayerLatencyPolicyArrayOutput) ToGameSessionQueuePlayerLatencyPolicyArrayOutput() GameSessionQueuePlayerLatencyPolicyArrayOutput {
	return o
}

func (o GameSessionQueuePlayerLatencyPolicyArrayOutput) ToGameSessionQueuePlayerLatencyPolicyArrayOutputWithContext(ctx context.Context) GameSessionQueuePlayerLatencyPolicyArrayOutput {
	return o
}

func (o GameSessionQueuePlayerLatencyPolicyArrayOutput) Index(i pulumi.IntInput) GameSessionQueuePlayerLatencyPolicyOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GameSessionQueuePlayerLatencyPolicy {
		return vs[0].([]GameSessionQueuePlayerLatencyPolicy)[vs[1].(int)]
	}).(GameSessionQueuePlayerLatencyPolicyOutput)
}

type MatchmakingConfigurationGameProperty struct {
	// A game property key
	Key string `pulumi:"key"`
	// A game property value.
	Value string `pulumi:"value"`
}

// MatchmakingConfigurationGamePropertyInput is an input type that accepts MatchmakingConfigurationGamePropertyArgs and MatchmakingConfigurationGamePropertyOutput values.
// You can construct a concrete instance of `MatchmakingConfigurationGamePropertyInput` via:
//
//	MatchmakingConfigurationGamePropertyArgs{...}
type MatchmakingConfigurationGamePropertyInput interface {
	pulumi.Input

	ToMatchmakingConfigurationGamePropertyOutput() MatchmakingConfigurationGamePropertyOutput
	ToMatchmakingConfigurationGamePropertyOutputWithContext(context.Context) MatchmakingConfigurationGamePropertyOutput
}

type MatchmakingConfigurationGamePropertyArgs struct {
	// A game property key
	Key pulumi.StringInput `pulumi:"key"`
	// A game property value.
	Value pulumi.StringInput `pulumi:"value"`
}

func (MatchmakingConfigurationGamePropertyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*MatchmakingConfigurationGameProperty)(nil)).Elem()
}

func (i MatchmakingConfigurationGamePropertyArgs) ToMatchmakingConfigurationGamePropertyOutput() MatchmakingConfigurationGamePropertyOutput {
	return i.ToMatchmakingConfigurationGamePropertyOutputWithContext(context.Background())
}

func (i MatchmakingConfigurationGamePropertyArgs) ToMatchmakingConfigurationGamePropertyOutputWithContext(ctx context.Context) MatchmakingConfigurationGamePropertyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MatchmakingConfigurationGamePropertyOutput)
}

// MatchmakingConfigurationGamePropertyArrayInput is an input type that accepts MatchmakingConfigurationGamePropertyArray and MatchmakingConfigurationGamePropertyArrayOutput values.
// You can construct a concrete instance of `MatchmakingConfigurationGamePropertyArrayInput` via:
//
//	MatchmakingConfigurationGamePropertyArray{ MatchmakingConfigurationGamePropertyArgs{...} }
type MatchmakingConfigurationGamePropertyArrayInput interface {
	pulumi.Input

	ToMatchmakingConfigurationGamePropertyArrayOutput() MatchmakingConfigurationGamePropertyArrayOutput
	ToMatchmakingConfigurationGamePropertyArrayOutputWithContext(context.Context) MatchmakingConfigurationGamePropertyArrayOutput
}

type MatchmakingConfigurationGamePropertyArray []MatchmakingConfigurationGamePropertyInput

func (MatchmakingConfigurationGamePropertyArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]MatchmakingConfigurationGameProperty)(nil)).Elem()
}

func (i MatchmakingConfigurationGamePropertyArray) ToMatchmakingConfigurationGamePropertyArrayOutput() MatchmakingConfigurationGamePropertyArrayOutput {
	return i.ToMatchmakingConfigurationGamePropertyArrayOutputWithContext(context.Background())
}

func (i MatchmakingConfigurationGamePropertyArray) ToMatchmakingConfigurationGamePropertyArrayOutputWithContext(ctx context.Context) MatchmakingConfigurationGamePropertyArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(MatchmakingConfigurationGamePropertyArrayOutput)
}

type MatchmakingConfigurationGamePropertyOutput struct{ *pulumi.OutputState }

func (MatchmakingConfigurationGamePropertyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*MatchmakingConfigurationGameProperty)(nil)).Elem()
}

func (o MatchmakingConfigurationGamePropertyOutput) ToMatchmakingConfigurationGamePropertyOutput() MatchmakingConfigurationGamePropertyOutput {
	return o
}

func (o MatchmakingConfigurationGamePropertyOutput) ToMatchmakingConfigurationGamePropertyOutputWithContext(ctx context.Context) MatchmakingConfigurationGamePropertyOutput {
	return o
}

// A game property key
func (o MatchmakingConfigurationGamePropertyOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v MatchmakingConfigurationGameProperty) string { return v.Key }).(pulumi.StringOutput)
}

// A game property value.
func (o MatchmakingConfigurationGamePropertyOutput) Value() pulumi.StringOutput {
	return o.ApplyT(func(v MatchmakingConfigurationGameProperty) string { return v.Value }).(pulumi.StringOutput)
}

type MatchmakingConfigurationGamePropertyArrayOutput struct{ *pulumi.OutputState }

func (MatchmakingConfigurationGamePropertyArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]MatchmakingConfigurationGameProperty)(nil)).Elem()
}

func (o MatchmakingConfigurationGamePropertyArrayOutput) ToMatchmakingConfigurationGamePropertyArrayOutput() MatchmakingConfigurationGamePropertyArrayOutput {
	return o
}

func (o MatchmakingConfigurationGamePropertyArrayOutput) ToMatchmakingConfigurationGamePropertyArrayOutputWithContext(ctx context.Context) MatchmakingConfigurationGamePropertyArrayOutput {
	return o
}

func (o MatchmakingConfigurationGamePropertyArrayOutput) Index(i pulumi.IntInput) MatchmakingConfigurationGamePropertyOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) MatchmakingConfigurationGameProperty {
		return vs[0].([]MatchmakingConfigurationGameProperty)[vs[1].(int)]
	}).(MatchmakingConfigurationGamePropertyOutput)
}

type ScriptStorageLocation struct {
	// Name of your S3 bucket.
	Bucket string `pulumi:"bucket"`
	// Name of the zip file containing your script files.
	Key string `pulumi:"key"`
	// A specific version of the file. If not set, the latest version of the file is retrieved.
	ObjectVersion *string `pulumi:"objectVersion"`
	// ARN of the access role that allows Amazon GameLift to access your S3 bucket.
	RoleArn string `pulumi:"roleArn"`
}

// ScriptStorageLocationInput is an input type that accepts ScriptStorageLocationArgs and ScriptStorageLocationOutput values.
// You can construct a concrete instance of `ScriptStorageLocationInput` via:
//
//	ScriptStorageLocationArgs{...}
type ScriptStorageLocationInput interface {
	pulumi.Input

	ToScriptStorageLocationOutput() ScriptStorageLocationOutput
	ToScriptStorageLocationOutputWithContext(context.Context) ScriptStorageLocationOutput
}

type ScriptStorageLocationArgs struct {
	// Name of your S3 bucket.
	Bucket pulumi.StringInput `pulumi:"bucket"`
	// Name of the zip file containing your script files.
	Key pulumi.StringInput `pulumi:"key"`
	// A specific version of the file. If not set, the latest version of the file is retrieved.
	ObjectVersion pulumi.StringPtrInput `pulumi:"objectVersion"`
	// ARN of the access role that allows Amazon GameLift to access your S3 bucket.
	RoleArn pulumi.StringInput `pulumi:"roleArn"`
}

func (ScriptStorageLocationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ScriptStorageLocation)(nil)).Elem()
}

func (i ScriptStorageLocationArgs) ToScriptStorageLocationOutput() ScriptStorageLocationOutput {
	return i.ToScriptStorageLocationOutputWithContext(context.Background())
}

func (i ScriptStorageLocationArgs) ToScriptStorageLocationOutputWithContext(ctx context.Context) ScriptStorageLocationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScriptStorageLocationOutput)
}

func (i ScriptStorageLocationArgs) ToScriptStorageLocationPtrOutput() ScriptStorageLocationPtrOutput {
	return i.ToScriptStorageLocationPtrOutputWithContext(context.Background())
}

func (i ScriptStorageLocationArgs) ToScriptStorageLocationPtrOutputWithContext(ctx context.Context) ScriptStorageLocationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScriptStorageLocationOutput).ToScriptStorageLocationPtrOutputWithContext(ctx)
}

// ScriptStorageLocationPtrInput is an input type that accepts ScriptStorageLocationArgs, ScriptStorageLocationPtr and ScriptStorageLocationPtrOutput values.
// You can construct a concrete instance of `ScriptStorageLocationPtrInput` via:
//
//	        ScriptStorageLocationArgs{...}
//
//	or:
//
//	        nil
type ScriptStorageLocationPtrInput interface {
	pulumi.Input

	ToScriptStorageLocationPtrOutput() ScriptStorageLocationPtrOutput
	ToScriptStorageLocationPtrOutputWithContext(context.Context) ScriptStorageLocationPtrOutput
}

type scriptStorageLocationPtrType ScriptStorageLocationArgs

func ScriptStorageLocationPtr(v *ScriptStorageLocationArgs) ScriptStorageLocationPtrInput {
	return (*scriptStorageLocationPtrType)(v)
}

func (*scriptStorageLocationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ScriptStorageLocation)(nil)).Elem()
}

func (i *scriptStorageLocationPtrType) ToScriptStorageLocationPtrOutput() ScriptStorageLocationPtrOutput {
	return i.ToScriptStorageLocationPtrOutputWithContext(context.Background())
}

func (i *scriptStorageLocationPtrType) ToScriptStorageLocationPtrOutputWithContext(ctx context.Context) ScriptStorageLocationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ScriptStorageLocationPtrOutput)
}

type ScriptStorageLocationOutput struct{ *pulumi.OutputState }

func (ScriptStorageLocationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ScriptStorageLocation)(nil)).Elem()
}

func (o ScriptStorageLocationOutput) ToScriptStorageLocationOutput() ScriptStorageLocationOutput {
	return o
}

func (o ScriptStorageLocationOutput) ToScriptStorageLocationOutputWithContext(ctx context.Context) ScriptStorageLocationOutput {
	return o
}

func (o ScriptStorageLocationOutput) ToScriptStorageLocationPtrOutput() ScriptStorageLocationPtrOutput {
	return o.ToScriptStorageLocationPtrOutputWithContext(context.Background())
}

func (o ScriptStorageLocationOutput) ToScriptStorageLocationPtrOutputWithContext(ctx context.Context) ScriptStorageLocationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ScriptStorageLocation) *ScriptStorageLocation {
		return &v
	}).(ScriptStorageLocationPtrOutput)
}

// Name of your S3 bucket.
func (o ScriptStorageLocationOutput) Bucket() pulumi.StringOutput {
	return o.ApplyT(func(v ScriptStorageLocation) string { return v.Bucket }).(pulumi.StringOutput)
}

// Name of the zip file containing your script files.
func (o ScriptStorageLocationOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v ScriptStorageLocation) string { return v.Key }).(pulumi.StringOutput)
}

// A specific version of the file. If not set, the latest version of the file is retrieved.
func (o ScriptStorageLocationOutput) ObjectVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ScriptStorageLocation) *string { return v.ObjectVersion }).(pulumi.StringPtrOutput)
}

// ARN of the access role that allows Amazon GameLift to access your S3 bucket.
func (o ScriptStorageLocationOutput) RoleArn() pulumi.StringOutput {
	return o.ApplyT(func(v ScriptStorageLocation) string { return v.RoleArn }).(pulumi.StringOutput)
}

type ScriptStorageLocationPtrOutput struct{ *pulumi.OutputState }

func (ScriptStorageLocationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ScriptStorageLocation)(nil)).Elem()
}

func (o ScriptStorageLocationPtrOutput) ToScriptStorageLocationPtrOutput() ScriptStorageLocationPtrOutput {
	return o
}

func (o ScriptStorageLocationPtrOutput) ToScriptStorageLocationPtrOutputWithContext(ctx context.Context) ScriptStorageLocationPtrOutput {
	return o
}

func (o ScriptStorageLocationPtrOutput) Elem() ScriptStorageLocationOutput {
	return o.ApplyT(func(v *ScriptStorageLocation) ScriptStorageLocation {
		if v != nil {
			return *v
		}
		var ret ScriptStorageLocation
		return ret
	}).(ScriptStorageLocationOutput)
}

// Name of your S3 bucket.
func (o ScriptStorageLocationPtrOutput) Bucket() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ScriptStorageLocation) *string {
		if v == nil {
			return nil
		}
		return &v.Bucket
	}).(pulumi.StringPtrOutput)
}

// Name of the zip file containing your script files.
func (o ScriptStorageLocationPtrOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ScriptStorageLocation) *string {
		if v == nil {
			return nil
		}
		return &v.Key
	}).(pulumi.StringPtrOutput)
}

// A specific version of the file. If not set, the latest version of the file is retrieved.
func (o ScriptStorageLocationPtrOutput) ObjectVersion() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ScriptStorageLocation) *string {
		if v == nil {
			return nil
		}
		return v.ObjectVersion
	}).(pulumi.StringPtrOutput)
}

// ARN of the access role that allows Amazon GameLift to access your S3 bucket.
func (o ScriptStorageLocationPtrOutput) RoleArn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ScriptStorageLocation) *string {
		if v == nil {
			return nil
		}
		return &v.RoleArn
	}).(pulumi.StringPtrOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*AliasRoutingStrategyInput)(nil)).Elem(), AliasRoutingStrategyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AliasRoutingStrategyPtrInput)(nil)).Elem(), AliasRoutingStrategyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*BuildStorageLocationInput)(nil)).Elem(), BuildStorageLocationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*BuildStorageLocationPtrInput)(nil)).Elem(), BuildStorageLocationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*FleetCertificateConfigurationInput)(nil)).Elem(), FleetCertificateConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*FleetCertificateConfigurationPtrInput)(nil)).Elem(), FleetCertificateConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*FleetEc2InboundPermissionInput)(nil)).Elem(), FleetEc2InboundPermissionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*FleetEc2InboundPermissionArrayInput)(nil)).Elem(), FleetEc2InboundPermissionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*FleetResourceCreationLimitPolicyInput)(nil)).Elem(), FleetResourceCreationLimitPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*FleetResourceCreationLimitPolicyPtrInput)(nil)).Elem(), FleetResourceCreationLimitPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*FleetRuntimeConfigurationInput)(nil)).Elem(), FleetRuntimeConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*FleetRuntimeConfigurationPtrInput)(nil)).Elem(), FleetRuntimeConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*FleetRuntimeConfigurationServerProcessInput)(nil)).Elem(), FleetRuntimeConfigurationServerProcessArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*FleetRuntimeConfigurationServerProcessArrayInput)(nil)).Elem(), FleetRuntimeConfigurationServerProcessArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*GameServerGroupAutoScalingPolicyInput)(nil)).Elem(), GameServerGroupAutoScalingPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GameServerGroupAutoScalingPolicyPtrInput)(nil)).Elem(), GameServerGroupAutoScalingPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GameServerGroupAutoScalingPolicyTargetTrackingConfigurationInput)(nil)).Elem(), GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrInput)(nil)).Elem(), GameServerGroupAutoScalingPolicyTargetTrackingConfigurationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GameServerGroupInstanceDefinitionInput)(nil)).Elem(), GameServerGroupInstanceDefinitionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GameServerGroupInstanceDefinitionArrayInput)(nil)).Elem(), GameServerGroupInstanceDefinitionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*GameServerGroupLaunchTemplateInput)(nil)).Elem(), GameServerGroupLaunchTemplateArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GameServerGroupLaunchTemplatePtrInput)(nil)).Elem(), GameServerGroupLaunchTemplateArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GameSessionQueuePlayerLatencyPolicyInput)(nil)).Elem(), GameSessionQueuePlayerLatencyPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GameSessionQueuePlayerLatencyPolicyArrayInput)(nil)).Elem(), GameSessionQueuePlayerLatencyPolicyArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*MatchmakingConfigurationGamePropertyInput)(nil)).Elem(), MatchmakingConfigurationGamePropertyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*MatchmakingConfigurationGamePropertyArrayInput)(nil)).Elem(), MatchmakingConfigurationGamePropertyArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ScriptStorageLocationInput)(nil)).Elem(), ScriptStorageLocationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ScriptStorageLocationPtrInput)(nil)).Elem(), ScriptStorageLocationArgs{})
	pulumi.RegisterOutputType(AliasRoutingStrategyOutput{})
	pulumi.RegisterOutputType(AliasRoutingStrategyPtrOutput{})
	pulumi.RegisterOutputType(BuildStorageLocationOutput{})
	pulumi.RegisterOutputType(BuildStorageLocationPtrOutput{})
	pulumi.RegisterOutputType(FleetCertificateConfigurationOutput{})
	pulumi.RegisterOutputType(FleetCertificateConfigurationPtrOutput{})
	pulumi.RegisterOutputType(FleetEc2InboundPermissionOutput{})
	pulumi.RegisterOutputType(FleetEc2InboundPermissionArrayOutput{})
	pulumi.RegisterOutputType(FleetResourceCreationLimitPolicyOutput{})
	pulumi.RegisterOutputType(FleetResourceCreationLimitPolicyPtrOutput{})
	pulumi.RegisterOutputType(FleetRuntimeConfigurationOutput{})
	pulumi.RegisterOutputType(FleetRuntimeConfigurationPtrOutput{})
	pulumi.RegisterOutputType(FleetRuntimeConfigurationServerProcessOutput{})
	pulumi.RegisterOutputType(FleetRuntimeConfigurationServerProcessArrayOutput{})
	pulumi.RegisterOutputType(GameServerGroupAutoScalingPolicyOutput{})
	pulumi.RegisterOutputType(GameServerGroupAutoScalingPolicyPtrOutput{})
	pulumi.RegisterOutputType(GameServerGroupAutoScalingPolicyTargetTrackingConfigurationOutput{})
	pulumi.RegisterOutputType(GameServerGroupAutoScalingPolicyTargetTrackingConfigurationPtrOutput{})
	pulumi.RegisterOutputType(GameServerGroupInstanceDefinitionOutput{})
	pulumi.RegisterOutputType(GameServerGroupInstanceDefinitionArrayOutput{})
	pulumi.RegisterOutputType(GameServerGroupLaunchTemplateOutput{})
	pulumi.RegisterOutputType(GameServerGroupLaunchTemplatePtrOutput{})
	pulumi.RegisterOutputType(GameSessionQueuePlayerLatencyPolicyOutput{})
	pulumi.RegisterOutputType(GameSessionQueuePlayerLatencyPolicyArrayOutput{})
	pulumi.RegisterOutputType(MatchmakingConfigurationGamePropertyOutput{})
	pulumi.RegisterOutputType(MatchmakingConfigurationGamePropertyArrayOutput{})
	pulumi.RegisterOutputType(ScriptStorageLocationOutput{})
	pulumi.RegisterOutputType(ScriptStorageLocationPtrOutput{})
}