// Code generated by smithy-go-codegen DO NOT EDIT.

package appstream

import (
	"context"
	"fmt"
	awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
	"github.com/aws/aws-sdk-go-v2/service/appstream/types"
	"github.com/aws/smithy-go/middleware"
	smithyhttp "github.com/aws/smithy-go/transport/http"
)

// Creates a fleet. A fleet consists of streaming instances that your users access
// for their applications and desktops.
func (c *Client) CreateFleet(ctx context.Context, params *CreateFleetInput, optFns ...func(*Options)) (*CreateFleetOutput, error) {
	if params == nil {
		params = &CreateFleetInput{}
	}

	result, metadata, err := c.invokeOperation(ctx, "CreateFleet", params, optFns, c.addOperationCreateFleetMiddlewares)
	if err != nil {
		return nil, err
	}

	out := result.(*CreateFleetOutput)
	out.ResultMetadata = metadata
	return out, nil
}

type CreateFleetInput struct {

	// The instance type to use when launching fleet instances. The following instance
	// types are available:
	//
	//   - stream.standard.small
	//
	//   - stream.standard.medium
	//
	//   - stream.standard.large
	//
	//   - stream.standard.xlarge
	//
	//   - stream.standard.2xlarge
	//
	//   - stream.compute.large
	//
	//   - stream.compute.xlarge
	//
	//   - stream.compute.2xlarge
	//
	//   - stream.compute.4xlarge
	//
	//   - stream.compute.8xlarge
	//
	//   - stream.memory.large
	//
	//   - stream.memory.xlarge
	//
	//   - stream.memory.2xlarge
	//
	//   - stream.memory.4xlarge
	//
	//   - stream.memory.8xlarge
	//
	//   - stream.memory.z1d.large
	//
	//   - stream.memory.z1d.xlarge
	//
	//   - stream.memory.z1d.2xlarge
	//
	//   - stream.memory.z1d.3xlarge
	//
	//   - stream.memory.z1d.6xlarge
	//
	//   - stream.memory.z1d.12xlarge
	//
	//   - stream.graphics.g4dn.xlarge
	//
	//   - stream.graphics.g4dn.2xlarge
	//
	//   - stream.graphics.g4dn.4xlarge
	//
	//   - stream.graphics.g4dn.8xlarge
	//
	//   - stream.graphics.g4dn.12xlarge
	//
	//   - stream.graphics.g4dn.16xlarge
	//
	//   - stream.graphics.g5.xlarge
	//
	//   - stream.graphics.g5.2xlarge
	//
	//   - stream.graphics.g5.4xlarge
	//
	//   - stream.graphics.g5.8xlarge
	//
	//   - stream.graphics.g5.12xlarge
	//
	//   - stream.graphics.g5.16xlarge
	//
	//   - stream.graphics.g5.24xlarge
	//
	//   - stream.graphics.g6.xlarge
	//
	//   - stream.graphics.g6.2xlarge
	//
	//   - stream.graphics.g6.4xlarge
	//
	//   - stream.graphics.g6.8xlarge
	//
	//   - stream.graphics.g6.16xlarge
	//
	//   - stream.graphics.g6.12xlarge
	//
	//   - stream.graphics.g6.24xlarge
	//
	//   - stream.graphics.gr6.4xlarge
	//
	//   - stream.graphics.gr6.8xlarge
	//
	//   - stream.graphics.g6f.large
	//
	//   - stream.graphics.g6f.xlarge
	//
	//   - stream.graphics.g6f.2xlarge
	//
	//   - stream.graphics.g6f.4xlarge
	//
	//   - stream.graphics.gr6f.4xlarge
	//
	// The following instance types are available for Elastic fleets:
	//
	//   - stream.standard.small
	//
	//   - stream.standard.medium
	//
	//   - stream.standard.large
	//
	//   - stream.standard.xlarge
	//
	//   - stream.standard.2xlarge
	//
	// This member is required.
	InstanceType *string

	// A unique name for the fleet.
	//
	// This member is required.
	Name *string

	// The desired capacity for the fleet. This is not allowed for Elastic fleets. For
	// Elastic fleets, specify MaxConcurrentSessions instead.
	ComputeCapacity *types.ComputeCapacity

	// The description to display.
	Description *string

	// Set to true to disable Instance Metadata Service Version 1 (IMDSv1) and enforce
	// IMDSv2. Set to false to enable both IMDSv1 and IMDSv2.
	//
	// Before disabling IMDSv1, ensure your WorkSpaces Applications images are running
	// the agent version or managed image update released on or after January 16, 2024
	// to support IMDSv2 enforcement.
	DisableIMDSV1 *bool

	// The amount of time that a streaming session remains active after users
	// disconnect. If users try to reconnect to the streaming session after a
	// disconnection or network interruption within this time interval, they are
	// connected to their previous session. Otherwise, they are connected to a new
	// session with a new streaming instance.
	//
	// Specify a value between 60 and 36000.
	DisconnectTimeoutInSeconds *int32

	// The fleet name to display.
	DisplayName *string

	// The name of the directory and organizational unit (OU) to use to join the fleet
	// to a Microsoft Active Directory domain. This is not allowed for Elastic fleets.
	DomainJoinInfo *types.DomainJoinInfo

	// Enables or disables default internet access for the fleet.
	EnableDefaultInternetAccess *bool

	// The fleet type.
	//
	// ALWAYS_ON Provides users with instant-on access to their apps. You are charged
	// for all running instances in your fleet, even if no users are streaming apps.
	//
	// ON_DEMAND Provide users with access to applications after they connect, which
	// takes one to two minutes. You are charged for instance streaming when users are
	// connected and a small hourly fee for instances that are not streaming apps.
	FleetType types.FleetType

	// The Amazon Resource Name (ARN) of the IAM role to apply to the fleet. To assume
	// a role, a fleet instance calls the AWS Security Token Service (STS) AssumeRole
	// API operation and passes the ARN of the role to use. The operation creates a new
	// session with temporary credentials. WorkSpaces Applications retrieves the
	// temporary credentials and creates the appstream_machine_role credential profile
	// on the instance.
	//
	// For more information, see [Using an IAM Role to Grant Permissions to Applications and Scripts Running on WorkSpaces Applications Streaming Instances] in the Amazon WorkSpaces Applications Administration
	// Guide.
	//
	// [Using an IAM Role to Grant Permissions to Applications and Scripts Running on WorkSpaces Applications Streaming Instances]: https://docs.aws.amazon.com/appstream2/latest/developerguide/using-iam-roles-to-grant-permissions-to-applications-scripts-streaming-instances.html
	IamRoleArn *string

	// The amount of time that users can be idle (inactive) before they are
	// disconnected from their streaming session and the DisconnectTimeoutInSeconds
	// time interval begins. Users are notified before they are disconnected due to
	// inactivity. If they try to reconnect to the streaming session before the time
	// interval specified in DisconnectTimeoutInSeconds elapses, they are connected to
	// their previous session. Users are considered idle when they stop providing
	// keyboard or mouse input during their streaming session. File uploads and
	// downloads, audio in, audio out, and pixels changing do not qualify as user
	// activity. If users continue to be idle after the time interval in
	// IdleDisconnectTimeoutInSeconds elapses, they are disconnected.
	//
	// To prevent users from being disconnected due to inactivity, specify a value of
	// 0. Otherwise, specify a value between 60 and 36000. The default value is 0.
	//
	// If you enable this feature, we recommend that you specify a value that
	// corresponds exactly to a whole number of minutes (for example, 60, 120, and
	// 180). If you don't do this, the value is rounded to the nearest minute. For
	// example, if you specify a value of 70, users are disconnected after 1 minute of
	// inactivity. If you specify a value that is at the midpoint between two different
	// minutes, the value is rounded up. For example, if you specify a value of 90,
	// users are disconnected after 2 minutes of inactivity.
	IdleDisconnectTimeoutInSeconds *int32

	// The ARN of the public, private, or shared image to use.
	ImageArn *string

	// The name of the image used to create the fleet.
	ImageName *string

	// The maximum concurrent sessions of the Elastic fleet. This is required for
	// Elastic fleets, and not allowed for other fleet types.
	MaxConcurrentSessions *int32

	// The maximum number of user sessions on an instance. This only applies to
	// multi-session fleets.
	MaxSessionsPerInstance *int32

	// The maximum amount of time that a streaming session can remain active, in
	// seconds. If users are still connected to a streaming instance five minutes
	// before this limit is reached, they are prompted to save any open documents
	// before being disconnected. After this time elapses, the instance is terminated
	// and replaced by a new instance.
	//
	// Specify a value between 600 and 432000.
	MaxUserDurationInSeconds *int32

	// The fleet platform. WINDOWS_SERVER_2019, AMAZON_LINUX2 and UBUNTU_PRO_2404 are
	// supported for Elastic fleets.
	Platform types.PlatformType

	// The configuration for the root volume of fleet instances. Use this to customize
	// storage capacity from 200 GB up to 500 GB based on your application
	// requirements.
	RootVolumeConfig *types.VolumeConfig

	// The S3 location of the session scripts configuration zip file. This only
	// applies to Elastic fleets.
	SessionScriptS3Location *types.S3Location

	// The WorkSpaces Applications view that is displayed to your users when they
	// stream from the fleet. When APP is specified, only the windows of applications
	// opened by users display. When DESKTOP is specified, the standard desktop that
	// is provided by the operating system displays.
	//
	// The default value is APP .
	StreamView types.StreamView

	// The tags to associate with the fleet. A tag is a key-value pair, and the value
	// is optional. For example, Environment=Test. If you do not specify a value,
	// Environment=.
	//
	// If you do not specify a value, the value is set to an empty string.
	//
	// Generally allowed characters are: letters, numbers, and spaces representable in
	// UTF-8, and the following special characters:
	//
	// _ . : / = + \ - @
	//
	// For more information, see [Tagging Your Resources] in the Amazon WorkSpaces Applications Administration
	// Guide.
	//
	// [Tagging Your Resources]: https://docs.aws.amazon.com/appstream2/latest/developerguide/tagging-basic.html
	Tags map[string]string

	// The USB device filter strings that specify which USB devices a user can
	// redirect to the fleet streaming session, when using the Windows native client.
	// This is allowed but not required for Elastic fleets.
	UsbDeviceFilterStrings []string

	// The VPC configuration for the fleet. This is required for Elastic fleets, but
	// not required for other fleet types. Elastic fleets require that you specify at
	// least two subnets in different availability zones.
	VpcConfig *types.VpcConfig

	noSmithyDocumentSerde
}

type CreateFleetOutput struct {

	// Information about the fleet.
	Fleet *types.Fleet

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

	noSmithyDocumentSerde
}

func (c *Client) addOperationCreateFleetMiddlewares(stack *middleware.Stack, options Options) (err error) {
	if err := stack.Serialize.Add(&setOperationInputMiddleware{}, middleware.After); err != nil {
		return err
	}
	err = stack.Serialize.Add(&awsAwsjson11_serializeOpCreateFleet{}, middleware.After)
	if err != nil {
		return err
	}
	err = stack.Deserialize.Add(&awsAwsjson11_deserializeOpCreateFleet{}, middleware.After)
	if err != nil {
		return err
	}
	if err := addProtocolFinalizerMiddlewares(stack, options, "CreateFleet"); err != nil {
		return fmt.Errorf("add protocol finalizers: %v", err)
	}

	if err = addlegacyEndpointContextSetter(stack, options); err != nil {
		return err
	}
	if err = addSetLoggerMiddleware(stack, options); err != nil {
		return err
	}
	if err = addClientRequestID(stack); err != nil {
		return err
	}
	if err = addComputeContentLength(stack); err != nil {
		return err
	}
	if err = addResolveEndpointMiddleware(stack, options); err != nil {
		return err
	}
	if err = addComputePayloadSHA256(stack); err != nil {
		return err
	}
	if err = addRetry(stack, options); err != nil {
		return err
	}
	if err = addRawResponseToMetadata(stack); err != nil {
		return err
	}
	if err = addRecordResponseTiming(stack); err != nil {
		return err
	}
	if err = addSpanRetryLoop(stack, options); err != nil {
		return err
	}
	if err = addClientUserAgent(stack, options); err != nil {
		return err
	}
	if err = smithyhttp.AddErrorCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = smithyhttp.AddCloseResponseBodyMiddleware(stack); err != nil {
		return err
	}
	if err = addSetLegacyContextSigningOptionsMiddleware(stack); err != nil {
		return err
	}
	if err = addTimeOffsetBuild(stack, c); err != nil {
		return err
	}
	if err = addUserAgentRetryMode(stack, options); err != nil {
		return err
	}
	if err = addCredentialSource(stack, options); err != nil {
		return err
	}
	if err = addOpCreateFleetValidationMiddleware(stack); err != nil {
		return err
	}
	if err = stack.Initialize.Add(newServiceMetadataMiddleware_opCreateFleet(options.Region), middleware.Before); err != nil {
		return err
	}
	if err = addRecursionDetection(stack); err != nil {
		return err
	}
	if err = addRequestIDRetrieverMiddleware(stack); err != nil {
		return err
	}
	if err = addResponseErrorMiddleware(stack); err != nil {
		return err
	}
	if err = addRequestResponseLogging(stack, options); err != nil {
		return err
	}
	if err = addDisableHTTPSMiddleware(stack, options); err != nil {
		return err
	}
	if err = addInterceptBeforeRetryLoop(stack, options); err != nil {
		return err
	}
	if err = addInterceptAttempt(stack, options); err != nil {
		return err
	}
	if err = addInterceptors(stack, options); err != nil {
		return err
	}
	return nil
}

func newServiceMetadataMiddleware_opCreateFleet(region string) *awsmiddleware.RegisterServiceMetadata {
	return &awsmiddleware.RegisterServiceMetadata{
		Region:        region,
		ServiceID:     ServiceID,
		OperationName: "CreateFleet",
	}
}
