@aws-sdk/client-appstream 3.34.0 → 3.37.0

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

@@ -0,0 +1,1830 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export declare enum AccessEndpointType {
+    STREAMING = "STREAMING"
+}
+
+export interface AccessEndpoint {
+    
+    EndpointType: AccessEndpointType | string | undefined;
+    
+    VpceId?: string;
+}
+export declare namespace AccessEndpoint {
+    
+    const filterSensitiveLog: (obj: AccessEndpoint) => any;
+}
+export declare enum Action {
+    CLIPBOARD_COPY_FROM_LOCAL_DEVICE = "CLIPBOARD_COPY_FROM_LOCAL_DEVICE",
+    CLIPBOARD_COPY_TO_LOCAL_DEVICE = "CLIPBOARD_COPY_TO_LOCAL_DEVICE",
+    DOMAIN_PASSWORD_SIGNIN = "DOMAIN_PASSWORD_SIGNIN",
+    DOMAIN_SMART_CARD_SIGNIN = "DOMAIN_SMART_CARD_SIGNIN",
+    FILE_DOWNLOAD = "FILE_DOWNLOAD",
+    FILE_UPLOAD = "FILE_UPLOAD",
+    PRINTING_TO_LOCAL_DEVICE = "PRINTING_TO_LOCAL_DEVICE"
+}
+
+export interface Application {
+    
+    Name?: string;
+    
+    DisplayName?: string;
+    
+    IconURL?: string;
+    
+    LaunchPath?: string;
+    
+    LaunchParameters?: string;
+    
+    Enabled?: boolean;
+    
+    Metadata?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Application {
+    
+    const filterSensitiveLog: (obj: Application) => any;
+}
+
+export interface ApplicationSettings {
+    
+    Enabled: boolean | undefined;
+    
+    SettingsGroup?: string;
+}
+export declare namespace ApplicationSettings {
+    
+    const filterSensitiveLog: (obj: ApplicationSettings) => any;
+}
+
+export interface ApplicationSettingsResponse {
+    
+    Enabled?: boolean;
+    
+    SettingsGroup?: string;
+    
+    S3BucketName?: string;
+}
+export declare namespace ApplicationSettingsResponse {
+    
+    const filterSensitiveLog: (obj: ApplicationSettingsResponse) => any;
+}
+export interface AssociateFleetRequest {
+    
+    FleetName: string | undefined;
+    
+    StackName: string | undefined;
+}
+export declare namespace AssociateFleetRequest {
+    
+    const filterSensitiveLog: (obj: AssociateFleetRequest) => any;
+}
+export interface AssociateFleetResult {
+}
+export declare namespace AssociateFleetResult {
+    
+    const filterSensitiveLog: (obj: AssociateFleetResult) => any;
+}
+
+export interface ConcurrentModificationException extends __SmithyException, $MetadataBearer {
+    name: "ConcurrentModificationException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ConcurrentModificationException {
+    
+    const filterSensitiveLog: (obj: ConcurrentModificationException) => any;
+}
+
+export interface IncompatibleImageException extends __SmithyException, $MetadataBearer {
+    name: "IncompatibleImageException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace IncompatibleImageException {
+    
+    const filterSensitiveLog: (obj: IncompatibleImageException) => any;
+}
+
+export interface InvalidAccountStatusException extends __SmithyException, $MetadataBearer {
+    name: "InvalidAccountStatusException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidAccountStatusException {
+    
+    const filterSensitiveLog: (obj: InvalidAccountStatusException) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace LimitExceededException {
+    
+    const filterSensitiveLog: (obj: LimitExceededException) => any;
+}
+
+export interface OperationNotPermittedException extends __SmithyException, $MetadataBearer {
+    name: "OperationNotPermittedException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace OperationNotPermittedException {
+    
+    const filterSensitiveLog: (obj: OperationNotPermittedException) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+export declare enum AuthenticationType {
+    API = "API",
+    SAML = "SAML",
+    USERPOOL = "USERPOOL"
+}
+
+export interface UserStackAssociation {
+    
+    StackName: string | undefined;
+    
+    UserName: string | undefined;
+    
+    AuthenticationType: AuthenticationType | string | undefined;
+    
+    SendEmailNotification?: boolean;
+}
+export declare namespace UserStackAssociation {
+    
+    const filterSensitiveLog: (obj: UserStackAssociation) => any;
+}
+export interface BatchAssociateUserStackRequest {
+    
+    UserStackAssociations: UserStackAssociation[] | undefined;
+}
+export declare namespace BatchAssociateUserStackRequest {
+    
+    const filterSensitiveLog: (obj: BatchAssociateUserStackRequest) => any;
+}
+export declare enum UserStackAssociationErrorCode {
+    DIRECTORY_NOT_FOUND = "DIRECTORY_NOT_FOUND",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    STACK_NOT_FOUND = "STACK_NOT_FOUND",
+    USER_NAME_NOT_FOUND = "USER_NAME_NOT_FOUND"
+}
+
+export interface UserStackAssociationError {
+    
+    UserStackAssociation?: UserStackAssociation;
+    
+    ErrorCode?: UserStackAssociationErrorCode | string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace UserStackAssociationError {
+    
+    const filterSensitiveLog: (obj: UserStackAssociationError) => any;
+}
+export interface BatchAssociateUserStackResult {
+    
+    errors?: UserStackAssociationError[];
+}
+export declare namespace BatchAssociateUserStackResult {
+    
+    const filterSensitiveLog: (obj: BatchAssociateUserStackResult) => any;
+}
+
+export interface InvalidParameterCombinationException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterCombinationException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidParameterCombinationException {
+    
+    const filterSensitiveLog: (obj: InvalidParameterCombinationException) => any;
+}
+export interface BatchDisassociateUserStackRequest {
+    
+    UserStackAssociations: UserStackAssociation[] | undefined;
+}
+export declare namespace BatchDisassociateUserStackRequest {
+    
+    const filterSensitiveLog: (obj: BatchDisassociateUserStackRequest) => any;
+}
+export interface BatchDisassociateUserStackResult {
+    
+    errors?: UserStackAssociationError[];
+}
+export declare namespace BatchDisassociateUserStackResult {
+    
+    const filterSensitiveLog: (obj: BatchDisassociateUserStackResult) => any;
+}
+
+export interface ComputeCapacity {
+    
+    DesiredInstances: number | undefined;
+}
+export declare namespace ComputeCapacity {
+    
+    const filterSensitiveLog: (obj: ComputeCapacity) => any;
+}
+
+export interface ComputeCapacityStatus {
+    
+    Desired: number | undefined;
+    
+    Running?: number;
+    
+    InUse?: number;
+    
+    Available?: number;
+}
+export declare namespace ComputeCapacityStatus {
+    
+    const filterSensitiveLog: (obj: ComputeCapacityStatus) => any;
+}
+export interface CopyImageRequest {
+    
+    SourceImageName: string | undefined;
+    
+    DestinationImageName: string | undefined;
+    
+    DestinationRegion: string | undefined;
+    
+    DestinationImageDescription?: string;
+}
+export declare namespace CopyImageRequest {
+    
+    const filterSensitiveLog: (obj: CopyImageRequest) => any;
+}
+export interface CopyImageResponse {
+    
+    DestinationImageName?: string;
+}
+export declare namespace CopyImageResponse {
+    
+    const filterSensitiveLog: (obj: CopyImageResponse) => any;
+}
+
+export interface ResourceAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "ResourceAlreadyExistsException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ResourceAlreadyExistsException {
+    
+    const filterSensitiveLog: (obj: ResourceAlreadyExistsException) => any;
+}
+
+export interface ResourceNotAvailableException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotAvailableException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ResourceNotAvailableException {
+    
+    const filterSensitiveLog: (obj: ResourceNotAvailableException) => any;
+}
+
+export interface ServiceAccountCredentials {
+    
+    AccountName: string | undefined;
+    
+    AccountPassword: string | undefined;
+}
+export declare namespace ServiceAccountCredentials {
+    
+    const filterSensitiveLog: (obj: ServiceAccountCredentials) => any;
+}
+export interface CreateDirectoryConfigRequest {
+    
+    DirectoryName: string | undefined;
+    
+    OrganizationalUnitDistinguishedNames: string[] | undefined;
+    
+    ServiceAccountCredentials?: ServiceAccountCredentials;
+}
+export declare namespace CreateDirectoryConfigRequest {
+    
+    const filterSensitiveLog: (obj: CreateDirectoryConfigRequest) => any;
+}
+
+export interface DirectoryConfig {
+    
+    DirectoryName: string | undefined;
+    
+    OrganizationalUnitDistinguishedNames?: string[];
+    
+    ServiceAccountCredentials?: ServiceAccountCredentials;
+    
+    CreatedTime?: Date;
+}
+export declare namespace DirectoryConfig {
+    
+    const filterSensitiveLog: (obj: DirectoryConfig) => any;
+}
+export interface CreateDirectoryConfigResult {
+    
+    DirectoryConfig?: DirectoryConfig;
+}
+export declare namespace CreateDirectoryConfigResult {
+    
+    const filterSensitiveLog: (obj: CreateDirectoryConfigResult) => any;
+}
+
+export interface InvalidRoleException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRoleException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace InvalidRoleException {
+    
+    const filterSensitiveLog: (obj: InvalidRoleException) => any;
+}
+
+export interface DomainJoinInfo {
+    
+    DirectoryName?: string;
+    
+    OrganizationalUnitDistinguishedName?: string;
+}
+export declare namespace DomainJoinInfo {
+    
+    const filterSensitiveLog: (obj: DomainJoinInfo) => any;
+}
+export declare enum FleetType {
+    ALWAYS_ON = "ALWAYS_ON",
+    ON_DEMAND = "ON_DEMAND"
+}
+export declare enum StreamView {
+    APP = "APP",
+    DESKTOP = "DESKTOP"
+}
+
+export interface VpcConfig {
+    
+    SubnetIds?: string[];
+    
+    SecurityGroupIds?: string[];
+}
+export declare namespace VpcConfig {
+    
+    const filterSensitiveLog: (obj: VpcConfig) => any;
+}
+export interface CreateFleetRequest {
+    
+    Name: string | undefined;
+    
+    ImageName?: string;
+    
+    ImageArn?: string;
+    
+    InstanceType: string | undefined;
+    
+    FleetType?: FleetType | string;
+    
+    ComputeCapacity: ComputeCapacity | undefined;
+    
+    VpcConfig?: VpcConfig;
+    
+    MaxUserDurationInSeconds?: number;
+    
+    DisconnectTimeoutInSeconds?: number;
+    
+    Description?: string;
+    
+    DisplayName?: string;
+    
+    EnableDefaultInternetAccess?: boolean;
+    
+    DomainJoinInfo?: DomainJoinInfo;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    IdleDisconnectTimeoutInSeconds?: number;
+    
+    IamRoleArn?: string;
+    
+    StreamView?: StreamView | string;
+}
+export declare namespace CreateFleetRequest {
+    
+    const filterSensitiveLog: (obj: CreateFleetRequest) => any;
+}
+export declare enum FleetErrorCode {
+    DOMAIN_JOIN_ERROR_ACCESS_DENIED = "DOMAIN_JOIN_ERROR_ACCESS_DENIED",
+    DOMAIN_JOIN_ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED = "DOMAIN_JOIN_ERROR_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED",
+    DOMAIN_JOIN_ERROR_FILE_NOT_FOUND = "DOMAIN_JOIN_ERROR_FILE_NOT_FOUND",
+    DOMAIN_JOIN_ERROR_INVALID_PARAMETER = "DOMAIN_JOIN_ERROR_INVALID_PARAMETER",
+    DOMAIN_JOIN_ERROR_LOGON_FAILURE = "DOMAIN_JOIN_ERROR_LOGON_FAILURE",
+    DOMAIN_JOIN_ERROR_MORE_DATA = "DOMAIN_JOIN_ERROR_MORE_DATA",
+    DOMAIN_JOIN_ERROR_NOT_SUPPORTED = "DOMAIN_JOIN_ERROR_NOT_SUPPORTED",
+    DOMAIN_JOIN_ERROR_NO_SUCH_DOMAIN = "DOMAIN_JOIN_ERROR_NO_SUCH_DOMAIN",
+    DOMAIN_JOIN_INTERNAL_SERVICE_ERROR = "DOMAIN_JOIN_INTERNAL_SERVICE_ERROR",
+    DOMAIN_JOIN_NERR_INVALID_WORKGROUP_NAME = "DOMAIN_JOIN_NERR_INVALID_WORKGROUP_NAME",
+    DOMAIN_JOIN_NERR_PASSWORD_EXPIRED = "DOMAIN_JOIN_NERR_PASSWORD_EXPIRED",
+    DOMAIN_JOIN_NERR_WORKSTATION_NOT_STARTED = "DOMAIN_JOIN_NERR_WORKSTATION_NOT_STARTED",
+    FLEET_INSTANCE_PROVISIONING_FAILURE = "FLEET_INSTANCE_PROVISIONING_FAILURE",
+    FLEET_STOPPED = "FLEET_STOPPED",
+    IAM_SERVICE_ROLE_IS_MISSING = "IAM_SERVICE_ROLE_IS_MISSING",
+    IAM_SERVICE_ROLE_MISSING_DESCRIBE_SECURITY_GROUPS_ACTION = "IAM_SERVICE_ROLE_MISSING_DESCRIBE_SECURITY_GROUPS_ACTION",
+    IAM_SERVICE_ROLE_MISSING_DESCRIBE_SUBNET_ACTION = "IAM_SERVICE_ROLE_MISSING_DESCRIBE_SUBNET_ACTION",
+    IAM_SERVICE_ROLE_MISSING_ENI_CREATE_ACTION = "IAM_SERVICE_ROLE_MISSING_ENI_CREATE_ACTION",
+    IAM_SERVICE_ROLE_MISSING_ENI_DELETE_ACTION = "IAM_SERVICE_ROLE_MISSING_ENI_DELETE_ACTION",
+    IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION = "IAM_SERVICE_ROLE_MISSING_ENI_DESCRIBE_ACTION",
+    IGW_NOT_ATTACHED = "IGW_NOT_ATTACHED",
+    IMAGE_NOT_FOUND = "IMAGE_NOT_FOUND",
+    INTERNAL_SERVICE_ERROR = "INTERNAL_SERVICE_ERROR",
+    INVALID_SUBNET_CONFIGURATION = "INVALID_SUBNET_CONFIGURATION",
+    MACHINE_ROLE_IS_MISSING = "MACHINE_ROLE_IS_MISSING",
+    NETWORK_INTERFACE_LIMIT_EXCEEDED = "NETWORK_INTERFACE_LIMIT_EXCEEDED",
+    SECURITY_GROUPS_NOT_FOUND = "SECURITY_GROUPS_NOT_FOUND",
+    STS_DISABLED_IN_REGION = "STS_DISABLED_IN_REGION",
+    SUBNET_HAS_INSUFFICIENT_IP_ADDRESSES = "SUBNET_HAS_INSUFFICIENT_IP_ADDRESSES",
+    SUBNET_NOT_FOUND = "SUBNET_NOT_FOUND"
+}
+
+export interface FleetError {
+    
+    ErrorCode?: FleetErrorCode | string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace FleetError {
+    
+    const filterSensitiveLog: (obj: FleetError) => any;
+}
+export declare enum FleetState {
+    RUNNING = "RUNNING",
+    STARTING = "STARTING",
+    STOPPED = "STOPPED",
+    STOPPING = "STOPPING"
+}
+
+export interface Fleet {
+    
+    Arn: string | undefined;
+    
+    Name: string | undefined;
+    
+    DisplayName?: string;
+    
+    Description?: string;
+    
+    ImageName?: string;
+    
+    ImageArn?: string;
+    
+    InstanceType: string | undefined;
+    
+    FleetType?: FleetType | string;
+    
+    ComputeCapacityStatus: ComputeCapacityStatus | undefined;
+    
+    MaxUserDurationInSeconds?: number;
+    
+    DisconnectTimeoutInSeconds?: number;
+    
+    State: FleetState | string | undefined;
+    
+    VpcConfig?: VpcConfig;
+    
+    CreatedTime?: Date;
+    
+    FleetErrors?: FleetError[];
+    
+    EnableDefaultInternetAccess?: boolean;
+    
+    DomainJoinInfo?: DomainJoinInfo;
+    
+    IdleDisconnectTimeoutInSeconds?: number;
+    
+    IamRoleArn?: string;
+    
+    StreamView?: StreamView | string;
+}
+export declare namespace Fleet {
+    
+    const filterSensitiveLog: (obj: Fleet) => any;
+}
+export interface CreateFleetResult {
+    
+    Fleet?: Fleet;
+}
+export declare namespace CreateFleetResult {
+    
+    const filterSensitiveLog: (obj: CreateFleetResult) => any;
+}
+
+export interface RequestLimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "RequestLimitExceededException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace RequestLimitExceededException {
+    
+    const filterSensitiveLog: (obj: RequestLimitExceededException) => any;
+}
+export interface CreateImageBuilderRequest {
+    
+    Name: string | undefined;
+    
+    ImageName?: string;
+    
+    ImageArn?: string;
+    
+    InstanceType: string | undefined;
+    
+    Description?: string;
+    
+    DisplayName?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    IamRoleArn?: string;
+    
+    EnableDefaultInternetAccess?: boolean;
+    
+    DomainJoinInfo?: DomainJoinInfo;
+    
+    AppstreamAgentVersion?: string;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    AccessEndpoints?: AccessEndpoint[];
+}
+export declare namespace CreateImageBuilderRequest {
+    
+    const filterSensitiveLog: (obj: CreateImageBuilderRequest) => any;
+}
+
+export interface ResourceError {
+    
+    ErrorCode?: FleetErrorCode | string;
+    
+    ErrorMessage?: string;
+    
+    ErrorTimestamp?: Date;
+}
+export declare namespace ResourceError {
+    
+    const filterSensitiveLog: (obj: ResourceError) => any;
+}
+
+export interface NetworkAccessConfiguration {
+    
+    EniPrivateIpAddress?: string;
+    
+    EniId?: string;
+}
+export declare namespace NetworkAccessConfiguration {
+    
+    const filterSensitiveLog: (obj: NetworkAccessConfiguration) => any;
+}
+export declare type PlatformType = "WINDOWS" | "WINDOWS_SERVER_2016" | "WINDOWS_SERVER_2019";
+export declare enum ImageBuilderState {
+    DELETING = "DELETING",
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    PENDING_QUALIFICATION = "PENDING_QUALIFICATION",
+    REBOOTING = "REBOOTING",
+    RUNNING = "RUNNING",
+    SNAPSHOTTING = "SNAPSHOTTING",
+    STOPPED = "STOPPED",
+    STOPPING = "STOPPING",
+    UPDATING = "UPDATING",
+    UPDATING_AGENT = "UPDATING_AGENT"
+}
+export declare enum ImageBuilderStateChangeReasonCode {
+    IMAGE_UNAVAILABLE = "IMAGE_UNAVAILABLE",
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+}
+
+export interface ImageBuilderStateChangeReason {
+    
+    Code?: ImageBuilderStateChangeReasonCode | string;
+    
+    Message?: string;
+}
+export declare namespace ImageBuilderStateChangeReason {
+    
+    const filterSensitiveLog: (obj: ImageBuilderStateChangeReason) => any;
+}
+
+export interface ImageBuilder {
+    
+    Name: string | undefined;
+    
+    Arn?: string;
+    
+    ImageArn?: string;
+    
+    Description?: string;
+    
+    DisplayName?: string;
+    
+    VpcConfig?: VpcConfig;
+    
+    InstanceType?: string;
+    
+    Platform?: PlatformType | string;
+    
+    IamRoleArn?: string;
+    
+    State?: ImageBuilderState | string;
+    
+    StateChangeReason?: ImageBuilderStateChangeReason;
+    
+    CreatedTime?: Date;
+    
+    EnableDefaultInternetAccess?: boolean;
+    
+    DomainJoinInfo?: DomainJoinInfo;
+    
+    NetworkAccessConfiguration?: NetworkAccessConfiguration;
+    
+    ImageBuilderErrors?: ResourceError[];
+    
+    AppstreamAgentVersion?: string;
+    
+    AccessEndpoints?: AccessEndpoint[];
+}
+export declare namespace ImageBuilder {
+    
+    const filterSensitiveLog: (obj: ImageBuilder) => any;
+}
+export interface CreateImageBuilderResult {
+    
+    ImageBuilder?: ImageBuilder;
+}
+export declare namespace CreateImageBuilderResult {
+    
+    const filterSensitiveLog: (obj: CreateImageBuilderResult) => any;
+}
+export interface CreateImageBuilderStreamingURLRequest {
+    
+    Name: string | undefined;
+    
+    Validity?: number;
+}
+export declare namespace CreateImageBuilderStreamingURLRequest {
+    
+    const filterSensitiveLog: (obj: CreateImageBuilderStreamingURLRequest) => any;
+}
+export interface CreateImageBuilderStreamingURLResult {
+    
+    StreamingURL?: string;
+    
+    Expires?: Date;
+}
+export declare namespace CreateImageBuilderStreamingURLResult {
+    
+    const filterSensitiveLog: (obj: CreateImageBuilderStreamingURLResult) => any;
+}
+export declare enum StorageConnectorType {
+    GOOGLE_DRIVE = "GOOGLE_DRIVE",
+    HOMEFOLDERS = "HOMEFOLDERS",
+    ONE_DRIVE = "ONE_DRIVE"
+}
+
+export interface StorageConnector {
+    
+    ConnectorType: StorageConnectorType | string | undefined;
+    
+    ResourceIdentifier?: string;
+    
+    Domains?: string[];
+}
+export declare namespace StorageConnector {
+    
+    const filterSensitiveLog: (obj: StorageConnector) => any;
+}
+export declare enum Permission {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface UserSetting {
+    
+    Action: Action | string | undefined;
+    
+    Permission: Permission | string | undefined;
+}
+export declare namespace UserSetting {
+    
+    const filterSensitiveLog: (obj: UserSetting) => any;
+}
+export interface CreateStackRequest {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    DisplayName?: string;
+    
+    StorageConnectors?: StorageConnector[];
+    
+    RedirectURL?: string;
+    
+    FeedbackURL?: string;
+    
+    UserSettings?: UserSetting[];
+    
+    ApplicationSettings?: ApplicationSettings;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    AccessEndpoints?: AccessEndpoint[];
+    
+    EmbedHostDomains?: string[];
+}
+export declare namespace CreateStackRequest {
+    
+    const filterSensitiveLog: (obj: CreateStackRequest) => any;
+}
+export declare enum StackErrorCode {
+    INTERNAL_SERVICE_ERROR = "INTERNAL_SERVICE_ERROR",
+    STORAGE_CONNECTOR_ERROR = "STORAGE_CONNECTOR_ERROR"
+}
+
+export interface StackError {
+    
+    ErrorCode?: StackErrorCode | string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace StackError {
+    
+    const filterSensitiveLog: (obj: StackError) => any;
+}
+
+export interface Stack {
+    
+    Arn?: string;
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    DisplayName?: string;
+    
+    CreatedTime?: Date;
+    
+    StorageConnectors?: StorageConnector[];
+    
+    RedirectURL?: string;
+    
+    FeedbackURL?: string;
+    
+    StackErrors?: StackError[];
+    
+    UserSettings?: UserSetting[];
+    
+    ApplicationSettings?: ApplicationSettingsResponse;
+    
+    AccessEndpoints?: AccessEndpoint[];
+    
+    EmbedHostDomains?: string[];
+}
+export declare namespace Stack {
+    
+    const filterSensitiveLog: (obj: Stack) => any;
+}
+export interface CreateStackResult {
+    
+    Stack?: Stack;
+}
+export declare namespace CreateStackResult {
+    
+    const filterSensitiveLog: (obj: CreateStackResult) => any;
+}
+export interface CreateStreamingURLRequest {
+    
+    StackName: string | undefined;
+    
+    FleetName: string | undefined;
+    
+    UserId: string | undefined;
+    
+    ApplicationId?: string;
+    
+    Validity?: number;
+    
+    SessionContext?: string;
+}
+export declare namespace CreateStreamingURLRequest {
+    
+    const filterSensitiveLog: (obj: CreateStreamingURLRequest) => any;
+}
+export interface CreateStreamingURLResult {
+    
+    StreamingURL?: string;
+    
+    Expires?: Date;
+}
+export declare namespace CreateStreamingURLResult {
+    
+    const filterSensitiveLog: (obj: CreateStreamingURLResult) => any;
+}
+export interface CreateUpdatedImageRequest {
+    
+    existingImageName: string | undefined;
+    
+    newImageName: string | undefined;
+    
+    newImageDescription?: string;
+    
+    newImageDisplayName?: string;
+    
+    newImageTags?: {
+        [key: string]: string;
+    };
+    
+    dryRun?: boolean;
+}
+export declare namespace CreateUpdatedImageRequest {
+    
+    const filterSensitiveLog: (obj: CreateUpdatedImageRequest) => any;
+}
+
+export interface ImagePermissions {
+    
+    allowFleet?: boolean;
+    
+    allowImageBuilder?: boolean;
+}
+export declare namespace ImagePermissions {
+    
+    const filterSensitiveLog: (obj: ImagePermissions) => any;
+}
+export declare enum ImageState {
+    AVAILABLE = "AVAILABLE",
+    COPYING = "COPYING",
+    CREATING = "CREATING",
+    DELETING = "DELETING",
+    FAILED = "FAILED",
+    IMPORTING = "IMPORTING",
+    PENDING = "PENDING"
+}
+export declare enum ImageStateChangeReasonCode {
+    IMAGE_BUILDER_NOT_AVAILABLE = "IMAGE_BUILDER_NOT_AVAILABLE",
+    IMAGE_COPY_FAILURE = "IMAGE_COPY_FAILURE",
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+}
+
+export interface ImageStateChangeReason {
+    
+    Code?: ImageStateChangeReasonCode | string;
+    
+    Message?: string;
+}
+export declare namespace ImageStateChangeReason {
+    
+    const filterSensitiveLog: (obj: ImageStateChangeReason) => any;
+}
+export declare enum VisibilityType {
+    PRIVATE = "PRIVATE",
+    PUBLIC = "PUBLIC",
+    SHARED = "SHARED"
+}
+
+export interface Image {
+    
+    Name: string | undefined;
+    
+    Arn?: string;
+    
+    BaseImageArn?: string;
+    
+    DisplayName?: string;
+    
+    State?: ImageState | string;
+    
+    Visibility?: VisibilityType | string;
+    
+    ImageBuilderSupported?: boolean;
+    
+    ImageBuilderName?: string;
+    
+    Platform?: PlatformType | string;
+    
+    Description?: string;
+    
+    StateChangeReason?: ImageStateChangeReason;
+    
+    Applications?: Application[];
+    
+    CreatedTime?: Date;
+    
+    PublicBaseImageReleasedDate?: Date;
+    
+    AppstreamAgentVersion?: string;
+    
+    ImagePermissions?: ImagePermissions;
+    
+    ImageErrors?: ResourceError[];
+}
+export declare namespace Image {
+    
+    const filterSensitiveLog: (obj: Image) => any;
+}
+export interface CreateUpdatedImageResult {
+    
+    image?: Image;
+    
+    canUpdateImage?: boolean;
+}
+export declare namespace CreateUpdatedImageResult {
+    
+    const filterSensitiveLog: (obj: CreateUpdatedImageResult) => any;
+}
+export interface CreateUsageReportSubscriptionRequest {
+}
+export declare namespace CreateUsageReportSubscriptionRequest {
+    
+    const filterSensitiveLog: (obj: CreateUsageReportSubscriptionRequest) => any;
+}
+export declare enum UsageReportSchedule {
+    DAILY = "DAILY"
+}
+export interface CreateUsageReportSubscriptionResult {
+    
+    S3BucketName?: string;
+    
+    Schedule?: UsageReportSchedule | string;
+}
+export declare namespace CreateUsageReportSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: CreateUsageReportSubscriptionResult) => any;
+}
+export declare enum MessageAction {
+    RESEND = "RESEND",
+    SUPPRESS = "SUPPRESS"
+}
+export interface CreateUserRequest {
+    
+    UserName: string | undefined;
+    
+    MessageAction?: MessageAction | string;
+    
+    FirstName?: string;
+    
+    LastName?: string;
+    
+    AuthenticationType: AuthenticationType | string | undefined;
+}
+export declare namespace CreateUserRequest {
+    
+    const filterSensitiveLog: (obj: CreateUserRequest) => any;
+}
+export interface CreateUserResult {
+}
+export declare namespace CreateUserResult {
+    
+    const filterSensitiveLog: (obj: CreateUserResult) => any;
+}
+export interface DeleteDirectoryConfigRequest {
+    
+    DirectoryName: string | undefined;
+}
+export declare namespace DeleteDirectoryConfigRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDirectoryConfigRequest) => any;
+}
+export interface DeleteDirectoryConfigResult {
+}
+export declare namespace DeleteDirectoryConfigResult {
+    
+    const filterSensitiveLog: (obj: DeleteDirectoryConfigResult) => any;
+}
+
+export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
+    name: "ResourceInUseException";
+    $fault: "client";
+    
+    Message?: string;
+}
+export declare namespace ResourceInUseException {
+    
+    const filterSensitiveLog: (obj: ResourceInUseException) => any;
+}
+export interface DeleteFleetRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteFleetRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFleetRequest) => any;
+}
+export interface DeleteFleetResult {
+}
+export declare namespace DeleteFleetResult {
+    
+    const filterSensitiveLog: (obj: DeleteFleetResult) => any;
+}
+export interface DeleteImageRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteImageRequest {
+    
+    const filterSensitiveLog: (obj: DeleteImageRequest) => any;
+}
+export interface DeleteImageResult {
+    
+    Image?: Image;
+}
+export declare namespace DeleteImageResult {
+    
+    const filterSensitiveLog: (obj: DeleteImageResult) => any;
+}
+export interface DeleteImageBuilderRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteImageBuilderRequest {
+    
+    const filterSensitiveLog: (obj: DeleteImageBuilderRequest) => any;
+}
+export interface DeleteImageBuilderResult {
+    
+    ImageBuilder?: ImageBuilder;
+}
+export declare namespace DeleteImageBuilderResult {
+    
+    const filterSensitiveLog: (obj: DeleteImageBuilderResult) => any;
+}
+export interface DeleteImagePermissionsRequest {
+    
+    Name: string | undefined;
+    
+    SharedAccountId: string | undefined;
+}
+export declare namespace DeleteImagePermissionsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteImagePermissionsRequest) => any;
+}
+export interface DeleteImagePermissionsResult {
+}
+export declare namespace DeleteImagePermissionsResult {
+    
+    const filterSensitiveLog: (obj: DeleteImagePermissionsResult) => any;
+}
+export interface DeleteStackRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteStackRequest {
+    
+    const filterSensitiveLog: (obj: DeleteStackRequest) => any;
+}
+export interface DeleteStackResult {
+}
+export declare namespace DeleteStackResult {
+    
+    const filterSensitiveLog: (obj: DeleteStackResult) => any;
+}
+export interface DeleteUsageReportSubscriptionRequest {
+}
+export declare namespace DeleteUsageReportSubscriptionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUsageReportSubscriptionRequest) => any;
+}
+export interface DeleteUsageReportSubscriptionResult {
+}
+export declare namespace DeleteUsageReportSubscriptionResult {
+    
+    const filterSensitiveLog: (obj: DeleteUsageReportSubscriptionResult) => any;
+}
+export interface DeleteUserRequest {
+    
+    UserName: string | undefined;
+    
+    AuthenticationType: AuthenticationType | string | undefined;
+}
+export declare namespace DeleteUserRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUserRequest) => any;
+}
+export interface DeleteUserResult {
+}
+export declare namespace DeleteUserResult {
+    
+    const filterSensitiveLog: (obj: DeleteUserResult) => any;
+}
+export interface DescribeDirectoryConfigsRequest {
+    
+    DirectoryNames?: string[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeDirectoryConfigsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDirectoryConfigsRequest) => any;
+}
+export interface DescribeDirectoryConfigsResult {
+    
+    DirectoryConfigs?: DirectoryConfig[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeDirectoryConfigsResult {
+    
+    const filterSensitiveLog: (obj: DescribeDirectoryConfigsResult) => any;
+}
+export interface DescribeFleetsRequest {
+    
+    Names?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeFleetsRequest) => any;
+}
+export interface DescribeFleetsResult {
+    
+    Fleets?: Fleet[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeFleetsResult {
+    
+    const filterSensitiveLog: (obj: DescribeFleetsResult) => any;
+}
+export interface DescribeImageBuildersRequest {
+    
+    Names?: string[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeImageBuildersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeImageBuildersRequest) => any;
+}
+export interface DescribeImageBuildersResult {
+    
+    ImageBuilders?: ImageBuilder[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeImageBuildersResult {
+    
+    const filterSensitiveLog: (obj: DescribeImageBuildersResult) => any;
+}
+export interface DescribeImagePermissionsRequest {
+    
+    Name: string | undefined;
+    
+    MaxResults?: number;
+    
+    SharedAwsAccountIds?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeImagePermissionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeImagePermissionsRequest) => any;
+}
+
+export interface SharedImagePermissions {
+    
+    sharedAccountId: string | undefined;
+    
+    imagePermissions: ImagePermissions | undefined;
+}
+export declare namespace SharedImagePermissions {
+    
+    const filterSensitiveLog: (obj: SharedImagePermissions) => any;
+}
+export interface DescribeImagePermissionsResult {
+    
+    Name?: string;
+    
+    SharedImagePermissionsList?: SharedImagePermissions[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeImagePermissionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeImagePermissionsResult) => any;
+}
+export interface DescribeImagesRequest {
+    
+    Names?: string[];
+    
+    Arns?: string[];
+    
+    Type?: VisibilityType | string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeImagesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeImagesRequest) => any;
+}
+export interface DescribeImagesResult {
+    
+    Images?: Image[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeImagesResult {
+    
+    const filterSensitiveLog: (obj: DescribeImagesResult) => any;
+}
+export interface DescribeSessionsRequest {
+    
+    StackName: string | undefined;
+    
+    FleetName: string | undefined;
+    
+    UserId?: string;
+    
+    NextToken?: string;
+    
+    Limit?: number;
+    
+    AuthenticationType?: AuthenticationType | string;
+}
+export declare namespace DescribeSessionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeSessionsRequest) => any;
+}
+export declare enum SessionConnectionState {
+    CONNECTED = "CONNECTED",
+    NOT_CONNECTED = "NOT_CONNECTED"
+}
+export declare enum SessionState {
+    ACTIVE = "ACTIVE",
+    EXPIRED = "EXPIRED",
+    PENDING = "PENDING"
+}
+
+export interface Session {
+    
+    Id: string | undefined;
+    
+    UserId: string | undefined;
+    
+    StackName: string | undefined;
+    
+    FleetName: string | undefined;
+    
+    State: SessionState | string | undefined;
+    
+    ConnectionState?: SessionConnectionState | string;
+    
+    StartTime?: Date;
+    
+    MaxExpirationTime?: Date;
+    
+    AuthenticationType?: AuthenticationType | string;
+    
+    NetworkAccessConfiguration?: NetworkAccessConfiguration;
+}
+export declare namespace Session {
+    
+    const filterSensitiveLog: (obj: Session) => any;
+}
+export interface DescribeSessionsResult {
+    
+    Sessions?: Session[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeSessionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeSessionsResult) => any;
+}
+export interface DescribeStacksRequest {
+    
+    Names?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeStacksRequest {
+    
+    const filterSensitiveLog: (obj: DescribeStacksRequest) => any;
+}
+export interface DescribeStacksResult {
+    
+    Stacks?: Stack[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeStacksResult {
+    
+    const filterSensitiveLog: (obj: DescribeStacksResult) => any;
+}
+export interface DescribeUsageReportSubscriptionsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeUsageReportSubscriptionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeUsageReportSubscriptionsRequest) => any;
+}
+export declare enum UsageReportExecutionErrorCode {
+    ACCESS_DENIED = "ACCESS_DENIED",
+    INTERNAL_SERVICE_ERROR = "INTERNAL_SERVICE_ERROR",
+    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND"
+}
+
+export interface LastReportGenerationExecutionError {
+    
+    ErrorCode?: UsageReportExecutionErrorCode | string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace LastReportGenerationExecutionError {
+    
+    const filterSensitiveLog: (obj: LastReportGenerationExecutionError) => any;
+}
+
+export interface UsageReportSubscription {
+    
+    S3BucketName?: string;
+    
+    Schedule?: UsageReportSchedule | string;
+    
+    LastGeneratedReportDate?: Date;
+    
+    SubscriptionErrors?: LastReportGenerationExecutionError[];
+}
+export declare namespace UsageReportSubscription {
+    
+    const filterSensitiveLog: (obj: UsageReportSubscription) => any;
+}
+export interface DescribeUsageReportSubscriptionsResult {
+    
+    UsageReportSubscriptions?: UsageReportSubscription[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeUsageReportSubscriptionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeUsageReportSubscriptionsResult) => any;
+}
+export interface DescribeUsersRequest {
+    
+    AuthenticationType: AuthenticationType | string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeUsersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeUsersRequest) => any;
+}
+
+export interface User {
+    
+    Arn?: string;
+    
+    UserName?: string;
+    
+    Enabled?: boolean;
+    
+    Status?: string;
+    
+    FirstName?: string;
+    
+    LastName?: string;
+    
+    CreatedTime?: Date;
+    
+    AuthenticationType: AuthenticationType | string | undefined;
+}
+export declare namespace User {
+    
+    const filterSensitiveLog: (obj: User) => any;
+}
+export interface DescribeUsersResult {
+    
+    Users?: User[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeUsersResult {
+    
+    const filterSensitiveLog: (obj: DescribeUsersResult) => any;
+}
+export interface DescribeUserStackAssociationsRequest {
+    
+    StackName?: string;
+    
+    UserName?: string;
+    
+    AuthenticationType?: AuthenticationType | string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeUserStackAssociationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeUserStackAssociationsRequest) => any;
+}
+export interface DescribeUserStackAssociationsResult {
+    
+    UserStackAssociations?: UserStackAssociation[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeUserStackAssociationsResult {
+    
+    const filterSensitiveLog: (obj: DescribeUserStackAssociationsResult) => any;
+}
+export interface DisableUserRequest {
+    
+    UserName: string | undefined;
+    
+    AuthenticationType: AuthenticationType | string | undefined;
+}
+export declare namespace DisableUserRequest {
+    
+    const filterSensitiveLog: (obj: DisableUserRequest) => any;
+}
+export interface DisableUserResult {
+}
+export declare namespace DisableUserResult {
+    
+    const filterSensitiveLog: (obj: DisableUserResult) => any;
+}
+export interface DisassociateFleetRequest {
+    
+    FleetName: string | undefined;
+    
+    StackName: string | undefined;
+}
+export declare namespace DisassociateFleetRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateFleetRequest) => any;
+}
+export interface DisassociateFleetResult {
+}
+export declare namespace DisassociateFleetResult {
+    
+    const filterSensitiveLog: (obj: DisassociateFleetResult) => any;
+}
+export interface EnableUserRequest {
+    
+    UserName: string | undefined;
+    
+    AuthenticationType: AuthenticationType | string | undefined;
+}
+export declare namespace EnableUserRequest {
+    
+    const filterSensitiveLog: (obj: EnableUserRequest) => any;
+}
+export interface EnableUserResult {
+}
+export declare namespace EnableUserResult {
+    
+    const filterSensitiveLog: (obj: EnableUserResult) => any;
+}
+export interface ExpireSessionRequest {
+    
+    SessionId: string | undefined;
+}
+export declare namespace ExpireSessionRequest {
+    
+    const filterSensitiveLog: (obj: ExpireSessionRequest) => any;
+}
+export interface ExpireSessionResult {
+}
+export declare namespace ExpireSessionResult {
+    
+    const filterSensitiveLog: (obj: ExpireSessionResult) => any;
+}
+export declare enum FleetAttribute {
+    DOMAIN_JOIN_INFO = "DOMAIN_JOIN_INFO",
+    IAM_ROLE_ARN = "IAM_ROLE_ARN",
+    VPC_CONFIGURATION = "VPC_CONFIGURATION",
+    VPC_CONFIGURATION_SECURITY_GROUP_IDS = "VPC_CONFIGURATION_SECURITY_GROUP_IDS"
+}
+export interface ListAssociatedFleetsRequest {
+    
+    StackName: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListAssociatedFleetsRequest {
+    
+    const filterSensitiveLog: (obj: ListAssociatedFleetsRequest) => any;
+}
+export interface ListAssociatedFleetsResult {
+    
+    Names?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAssociatedFleetsResult {
+    
+    const filterSensitiveLog: (obj: ListAssociatedFleetsResult) => any;
+}
+export interface ListAssociatedStacksRequest {
+    
+    FleetName: string | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListAssociatedStacksRequest {
+    
+    const filterSensitiveLog: (obj: ListAssociatedStacksRequest) => any;
+}
+export interface ListAssociatedStacksResult {
+    
+    Names?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAssociatedStacksResult {
+    
+    const filterSensitiveLog: (obj: ListAssociatedStacksResult) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface StartFleetRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace StartFleetRequest {
+    
+    const filterSensitiveLog: (obj: StartFleetRequest) => any;
+}
+export interface StartFleetResult {
+}
+export declare namespace StartFleetResult {
+    
+    const filterSensitiveLog: (obj: StartFleetResult) => any;
+}
+export interface StartImageBuilderRequest {
+    
+    Name: string | undefined;
+    
+    AppstreamAgentVersion?: string;
+}
+export declare namespace StartImageBuilderRequest {
+    
+    const filterSensitiveLog: (obj: StartImageBuilderRequest) => any;
+}
+export interface StartImageBuilderResult {
+    
+    ImageBuilder?: ImageBuilder;
+}
+export declare namespace StartImageBuilderResult {
+    
+    const filterSensitiveLog: (obj: StartImageBuilderResult) => any;
+}
+export interface StopFleetRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace StopFleetRequest {
+    
+    const filterSensitiveLog: (obj: StopFleetRequest) => any;
+}
+export interface StopFleetResult {
+}
+export declare namespace StopFleetResult {
+    
+    const filterSensitiveLog: (obj: StopFleetResult) => any;
+}
+export interface StopImageBuilderRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace StopImageBuilderRequest {
+    
+    const filterSensitiveLog: (obj: StopImageBuilderRequest) => any;
+}
+export interface StopImageBuilderResult {
+    
+    ImageBuilder?: ImageBuilder;
+}
+export declare namespace StopImageBuilderResult {
+    
+    const filterSensitiveLog: (obj: StopImageBuilderResult) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateDirectoryConfigRequest {
+    
+    DirectoryName: string | undefined;
+    
+    OrganizationalUnitDistinguishedNames?: string[];
+    
+    ServiceAccountCredentials?: ServiceAccountCredentials;
+}
+export declare namespace UpdateDirectoryConfigRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDirectoryConfigRequest) => any;
+}
+export interface UpdateDirectoryConfigResult {
+    
+    DirectoryConfig?: DirectoryConfig;
+}
+export declare namespace UpdateDirectoryConfigResult {
+    
+    const filterSensitiveLog: (obj: UpdateDirectoryConfigResult) => any;
+}
+export interface UpdateFleetRequest {
+    
+    ImageName?: string;
+    
+    ImageArn?: string;
+    
+    Name?: string;
+    
+    InstanceType?: string;
+    
+    ComputeCapacity?: ComputeCapacity;
+    
+    VpcConfig?: VpcConfig;
+    
+    MaxUserDurationInSeconds?: number;
+    
+    DisconnectTimeoutInSeconds?: number;
+    
+    DeleteVpcConfig?: boolean;
+    
+    Description?: string;
+    
+    DisplayName?: string;
+    
+    EnableDefaultInternetAccess?: boolean;
+    
+    DomainJoinInfo?: DomainJoinInfo;
+    
+    IdleDisconnectTimeoutInSeconds?: number;
+    
+    AttributesToDelete?: (FleetAttribute | string)[];
+    
+    IamRoleArn?: string;
+    
+    StreamView?: StreamView | string;
+}
+export declare namespace UpdateFleetRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFleetRequest) => any;
+}
+export interface UpdateFleetResult {
+    
+    Fleet?: Fleet;
+}
+export declare namespace UpdateFleetResult {
+    
+    const filterSensitiveLog: (obj: UpdateFleetResult) => any;
+}
+export interface UpdateImagePermissionsRequest {
+    
+    Name: string | undefined;
+    
+    SharedAccountId: string | undefined;
+    
+    ImagePermissions: ImagePermissions | undefined;
+}
+export declare namespace UpdateImagePermissionsRequest {
+    
+    const filterSensitiveLog: (obj: UpdateImagePermissionsRequest) => any;
+}
+export interface UpdateImagePermissionsResult {
+}
+export declare namespace UpdateImagePermissionsResult {
+    
+    const filterSensitiveLog: (obj: UpdateImagePermissionsResult) => any;
+}
+export declare enum StackAttribute {
+    ACCESS_ENDPOINTS = "ACCESS_ENDPOINTS",
+    EMBED_HOST_DOMAINS = "EMBED_HOST_DOMAINS",
+    FEEDBACK_URL = "FEEDBACK_URL",
+    IAM_ROLE_ARN = "IAM_ROLE_ARN",
+    REDIRECT_URL = "REDIRECT_URL",
+    STORAGE_CONNECTORS = "STORAGE_CONNECTORS",
+    STORAGE_CONNECTOR_GOOGLE_DRIVE = "STORAGE_CONNECTOR_GOOGLE_DRIVE",
+    STORAGE_CONNECTOR_HOMEFOLDERS = "STORAGE_CONNECTOR_HOMEFOLDERS",
+    STORAGE_CONNECTOR_ONE_DRIVE = "STORAGE_CONNECTOR_ONE_DRIVE",
+    THEME_NAME = "THEME_NAME",
+    USER_SETTINGS = "USER_SETTINGS"
+}
+export interface UpdateStackRequest {
+    
+    DisplayName?: string;
+    
+    Description?: string;
+    
+    Name: string | undefined;
+    
+    StorageConnectors?: StorageConnector[];
+    
+    DeleteStorageConnectors?: boolean;
+    
+    RedirectURL?: string;
+    
+    FeedbackURL?: string;
+    
+    AttributesToDelete?: (StackAttribute | string)[];
+    
+    UserSettings?: UserSetting[];
+    
+    ApplicationSettings?: ApplicationSettings;
+    
+    AccessEndpoints?: AccessEndpoint[];
+    
+    EmbedHostDomains?: string[];
+}
+export declare namespace UpdateStackRequest {
+    
+    const filterSensitiveLog: (obj: UpdateStackRequest) => any;
+}
+export interface UpdateStackResult {
+    
+    Stack?: Stack;
+}
+export declare namespace UpdateStackResult {
+    
+    const filterSensitiveLog: (obj: UpdateStackResult) => any;
+}