@aws-sdk/client-workspaces 3.50.0 → 3.53.0

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

@@ -0,0 +1,1840 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { WorkSpacesServiceException as __BaseException } from "./WorkSpacesServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+export declare enum AccessPropertyValue {
+    ALLOW = "ALLOW",
+    DENY = "DENY"
+}
+export declare enum DedicatedTenancySupportResultEnum {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+export declare enum DedicatedTenancyModificationStateEnum {
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    PENDING = "PENDING"
+}
+
+export interface AccountModification {
+    
+    ModificationState?: DedicatedTenancyModificationStateEnum | string;
+    
+    DedicatedTenancySupport?: DedicatedTenancySupportResultEnum | string;
+    
+    DedicatedTenancyManagementCidrRange?: string;
+    
+    StartTime?: Date;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace AccountModification {
+    
+    const filterSensitiveLog: (obj: AccountModification) => any;
+}
+export declare enum Application {
+    Microsoft_Office_2016 = "Microsoft_Office_2016",
+    Microsoft_Office_2019 = "Microsoft_Office_2019"
+}
+export interface AssociateConnectionAliasRequest {
+    
+    AliasId: string | undefined;
+    
+    ResourceId: string | undefined;
+}
+export declare namespace AssociateConnectionAliasRequest {
+    
+    const filterSensitiveLog: (obj: AssociateConnectionAliasRequest) => any;
+}
+export interface AssociateConnectionAliasResult {
+    
+    ConnectionIdentifier?: string;
+}
+export declare namespace AssociateConnectionAliasResult {
+    
+    const filterSensitiveLog: (obj: AssociateConnectionAliasResult) => any;
+}
+
+export declare class InvalidParameterValuesException extends __BaseException {
+    readonly name: "InvalidParameterValuesException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterValuesException, __BaseException>);
+}
+
+export declare class InvalidResourceStateException extends __BaseException {
+    readonly name: "InvalidResourceStateException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidResourceStateException, __BaseException>);
+}
+
+export declare class OperationNotSupportedException extends __BaseException {
+    readonly name: "OperationNotSupportedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OperationNotSupportedException, __BaseException>);
+}
+
+export declare class ResourceAssociatedException extends __BaseException {
+    readonly name: "ResourceAssociatedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceAssociatedException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    ResourceId?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+export interface AssociateIpGroupsRequest {
+    
+    DirectoryId: string | undefined;
+    
+    GroupIds: string[] | undefined;
+}
+export declare namespace AssociateIpGroupsRequest {
+    
+    const filterSensitiveLog: (obj: AssociateIpGroupsRequest) => any;
+}
+export interface AssociateIpGroupsResult {
+}
+export declare namespace AssociateIpGroupsResult {
+    
+    const filterSensitiveLog: (obj: AssociateIpGroupsResult) => any;
+}
+
+export declare class ResourceLimitExceededException extends __BaseException {
+    readonly name: "ResourceLimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceLimitExceededException, __BaseException>);
+}
+export declare enum AssociationStatus {
+    ASSOCIATED_WITH_OWNER_ACCOUNT = "ASSOCIATED_WITH_OWNER_ACCOUNT",
+    ASSOCIATED_WITH_SHARED_ACCOUNT = "ASSOCIATED_WITH_SHARED_ACCOUNT",
+    NOT_ASSOCIATED = "NOT_ASSOCIATED",
+    PENDING_ASSOCIATION = "PENDING_ASSOCIATION",
+    PENDING_DISASSOCIATION = "PENDING_DISASSOCIATION"
+}
+
+export interface IpRuleItem {
+    
+    ipRule?: string;
+    
+    ruleDesc?: string;
+}
+export declare namespace IpRuleItem {
+    
+    const filterSensitiveLog: (obj: IpRuleItem) => any;
+}
+export interface AuthorizeIpRulesRequest {
+    
+    GroupId: string | undefined;
+    
+    UserRules: IpRuleItem[] | undefined;
+}
+export declare namespace AuthorizeIpRulesRequest {
+    
+    const filterSensitiveLog: (obj: AuthorizeIpRulesRequest) => any;
+}
+export interface AuthorizeIpRulesResult {
+}
+export declare namespace AuthorizeIpRulesResult {
+    
+    const filterSensitiveLog: (obj: AuthorizeIpRulesResult) => any;
+}
+export declare enum Compute {
+    GRAPHICS = "GRAPHICS",
+    GRAPHICSPRO = "GRAPHICSPRO",
+    PERFORMANCE = "PERFORMANCE",
+    POWER = "POWER",
+    POWERPRO = "POWERPRO",
+    STANDARD = "STANDARD",
+    VALUE = "VALUE"
+}
+
+export interface ComputeType {
+    
+    Name?: Compute | string;
+}
+export declare namespace ComputeType {
+    
+    const filterSensitiveLog: (obj: ComputeType) => any;
+}
+
+export interface RootStorage {
+    
+    Capacity?: string;
+}
+export declare namespace RootStorage {
+    
+    const filterSensitiveLog: (obj: RootStorage) => any;
+}
+
+export interface UserStorage {
+    
+    Capacity?: string;
+}
+export declare namespace UserStorage {
+    
+    const filterSensitiveLog: (obj: UserStorage) => any;
+}
+
+export interface WorkspaceBundle {
+    
+    BundleId?: string;
+    
+    Name?: string;
+    
+    Owner?: string;
+    
+    Description?: string;
+    
+    ImageId?: string;
+    
+    RootStorage?: RootStorage;
+    
+    UserStorage?: UserStorage;
+    
+    ComputeType?: ComputeType;
+    
+    LastUpdatedTime?: Date;
+    
+    CreationTime?: Date;
+}
+export declare namespace WorkspaceBundle {
+    
+    const filterSensitiveLog: (obj: WorkspaceBundle) => any;
+}
+export declare enum ReconnectEnum {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface ClientProperties {
+    
+    ReconnectEnabled?: ReconnectEnum | string;
+}
+export declare namespace ClientProperties {
+    
+    const filterSensitiveLog: (obj: ClientProperties) => any;
+}
+
+export interface ClientPropertiesResult {
+    
+    ResourceId?: string;
+    
+    ClientProperties?: ClientProperties;
+}
+export declare namespace ClientPropertiesResult {
+    
+    const filterSensitiveLog: (obj: ClientPropertiesResult) => any;
+}
+
+export interface ConnectClientAddIn {
+    
+    AddInId?: string;
+    
+    ResourceId?: string;
+    
+    Name?: string;
+    
+    URL?: string;
+}
+export declare namespace ConnectClientAddIn {
+    
+    const filterSensitiveLog: (obj: ConnectClientAddIn) => any;
+}
+
+export interface ConnectionAliasAssociation {
+    
+    AssociationStatus?: AssociationStatus | string;
+    
+    AssociatedAccountId?: string;
+    
+    ResourceId?: string;
+    
+    ConnectionIdentifier?: string;
+}
+export declare namespace ConnectionAliasAssociation {
+    
+    const filterSensitiveLog: (obj: ConnectionAliasAssociation) => any;
+}
+export declare enum ConnectionAliasState {
+    CREATED = "CREATED",
+    CREATING = "CREATING",
+    DELETING = "DELETING"
+}
+
+export interface ConnectionAlias {
+    
+    ConnectionString?: string;
+    
+    AliasId?: string;
+    
+    State?: ConnectionAliasState | string;
+    
+    OwnerAccountId?: string;
+    
+    Associations?: ConnectionAliasAssociation[];
+}
+export declare namespace ConnectionAlias {
+    
+    const filterSensitiveLog: (obj: ConnectionAlias) => any;
+}
+
+export interface ConnectionAliasPermission {
+    
+    SharedAccountId: string | undefined;
+    
+    AllowAssociation: boolean | undefined;
+}
+export declare namespace ConnectionAliasPermission {
+    
+    const filterSensitiveLog: (obj: ConnectionAliasPermission) => any;
+}
+export declare enum ConnectionState {
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED",
+    UNKNOWN = "UNKNOWN"
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CopyWorkspaceImageRequest {
+    
+    Name: string | undefined;
+    
+    Description?: string;
+    
+    SourceImageId: string | undefined;
+    
+    SourceRegion: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CopyWorkspaceImageRequest {
+    
+    const filterSensitiveLog: (obj: CopyWorkspaceImageRequest) => any;
+}
+export interface CopyWorkspaceImageResult {
+    
+    ImageId?: string;
+}
+export declare namespace CopyWorkspaceImageResult {
+    
+    const filterSensitiveLog: (obj: CopyWorkspaceImageResult) => any;
+}
+
+export declare class ResourceAlreadyExistsException extends __BaseException {
+    readonly name: "ResourceAlreadyExistsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceAlreadyExistsException, __BaseException>);
+}
+
+export declare class ResourceUnavailableException extends __BaseException {
+    readonly name: "ResourceUnavailableException";
+    readonly $fault: "client";
+    
+    ResourceId?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceUnavailableException, __BaseException>);
+}
+export interface CreateConnectClientAddInRequest {
+    
+    ResourceId: string | undefined;
+    
+    Name: string | undefined;
+    
+    URL: string | undefined;
+}
+export declare namespace CreateConnectClientAddInRequest {
+    
+    const filterSensitiveLog: (obj: CreateConnectClientAddInRequest) => any;
+}
+export interface CreateConnectClientAddInResult {
+    
+    AddInId?: string;
+}
+export declare namespace CreateConnectClientAddInResult {
+    
+    const filterSensitiveLog: (obj: CreateConnectClientAddInResult) => any;
+}
+
+export declare class ResourceCreationFailedException extends __BaseException {
+    readonly name: "ResourceCreationFailedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceCreationFailedException, __BaseException>);
+}
+export interface CreateConnectionAliasRequest {
+    
+    ConnectionString: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateConnectionAliasRequest {
+    
+    const filterSensitiveLog: (obj: CreateConnectionAliasRequest) => any;
+}
+export interface CreateConnectionAliasResult {
+    
+    AliasId?: string;
+}
+export declare namespace CreateConnectionAliasResult {
+    
+    const filterSensitiveLog: (obj: CreateConnectionAliasResult) => any;
+}
+export interface CreateIpGroupRequest {
+    
+    GroupName: string | undefined;
+    
+    GroupDesc?: string;
+    
+    UserRules?: IpRuleItem[];
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateIpGroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateIpGroupRequest) => any;
+}
+export interface CreateIpGroupResult {
+    
+    GroupId?: string;
+}
+export declare namespace CreateIpGroupResult {
+    
+    const filterSensitiveLog: (obj: CreateIpGroupResult) => any;
+}
+export interface CreateTagsRequest {
+    
+    ResourceId: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace CreateTagsRequest {
+    
+    const filterSensitiveLog: (obj: CreateTagsRequest) => any;
+}
+export interface CreateTagsResult {
+}
+export declare namespace CreateTagsResult {
+    
+    const filterSensitiveLog: (obj: CreateTagsResult) => any;
+}
+export interface CreateUpdatedWorkspaceImageRequest {
+    
+    Name: string | undefined;
+    
+    Description: string | undefined;
+    
+    SourceImageId: string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateUpdatedWorkspaceImageRequest {
+    
+    const filterSensitiveLog: (obj: CreateUpdatedWorkspaceImageRequest) => any;
+}
+export interface CreateUpdatedWorkspaceImageResult {
+    
+    ImageId?: string;
+}
+export declare namespace CreateUpdatedWorkspaceImageResult {
+    
+    const filterSensitiveLog: (obj: CreateUpdatedWorkspaceImageResult) => any;
+}
+export interface CreateWorkspaceBundleRequest {
+    
+    BundleName: string | undefined;
+    
+    BundleDescription: string | undefined;
+    
+    ImageId: string | undefined;
+    
+    ComputeType: ComputeType | undefined;
+    
+    UserStorage: UserStorage | undefined;
+    
+    RootStorage?: RootStorage;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateWorkspaceBundleRequest {
+    
+    const filterSensitiveLog: (obj: CreateWorkspaceBundleRequest) => any;
+}
+export interface CreateWorkspaceBundleResult {
+    
+    WorkspaceBundle?: WorkspaceBundle;
+}
+export declare namespace CreateWorkspaceBundleResult {
+    
+    const filterSensitiveLog: (obj: CreateWorkspaceBundleResult) => any;
+}
+export declare enum RunningMode {
+    ALWAYS_ON = "ALWAYS_ON",
+    AUTO_STOP = "AUTO_STOP"
+}
+
+export interface WorkspaceProperties {
+    
+    RunningMode?: RunningMode | string;
+    
+    RunningModeAutoStopTimeoutInMinutes?: number;
+    
+    RootVolumeSizeGib?: number;
+    
+    UserVolumeSizeGib?: number;
+    
+    ComputeTypeName?: Compute | string;
+}
+export declare namespace WorkspaceProperties {
+    
+    const filterSensitiveLog: (obj: WorkspaceProperties) => any;
+}
+
+export interface WorkspaceRequest {
+    
+    DirectoryId: string | undefined;
+    
+    UserName: string | undefined;
+    
+    BundleId: string | undefined;
+    
+    VolumeEncryptionKey?: string;
+    
+    UserVolumeEncryptionEnabled?: boolean;
+    
+    RootVolumeEncryptionEnabled?: boolean;
+    
+    WorkspaceProperties?: WorkspaceProperties;
+    
+    Tags?: Tag[];
+}
+export declare namespace WorkspaceRequest {
+    
+    const filterSensitiveLog: (obj: WorkspaceRequest) => any;
+}
+export interface CreateWorkspacesRequest {
+    
+    Workspaces: WorkspaceRequest[] | undefined;
+}
+export declare namespace CreateWorkspacesRequest {
+    
+    const filterSensitiveLog: (obj: CreateWorkspacesRequest) => any;
+}
+
+export interface FailedCreateWorkspaceRequest {
+    
+    WorkspaceRequest?: WorkspaceRequest;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace FailedCreateWorkspaceRequest {
+    
+    const filterSensitiveLog: (obj: FailedCreateWorkspaceRequest) => any;
+}
+export declare enum ModificationResourceEnum {
+    COMPUTE_TYPE = "COMPUTE_TYPE",
+    ROOT_VOLUME = "ROOT_VOLUME",
+    USER_VOLUME = "USER_VOLUME"
+}
+export declare enum ModificationStateEnum {
+    UPDATE_INITIATED = "UPDATE_INITIATED",
+    UPDATE_IN_PROGRESS = "UPDATE_IN_PROGRESS"
+}
+
+export interface ModificationState {
+    
+    Resource?: ModificationResourceEnum | string;
+    
+    State?: ModificationStateEnum | string;
+}
+export declare namespace ModificationState {
+    
+    const filterSensitiveLog: (obj: ModificationState) => any;
+}
+export declare enum WorkspaceState {
+    ADMIN_MAINTENANCE = "ADMIN_MAINTENANCE",
+    AVAILABLE = "AVAILABLE",
+    ERROR = "ERROR",
+    IMPAIRED = "IMPAIRED",
+    MAINTENANCE = "MAINTENANCE",
+    PENDING = "PENDING",
+    REBOOTING = "REBOOTING",
+    REBUILDING = "REBUILDING",
+    RESTORING = "RESTORING",
+    STARTING = "STARTING",
+    STOPPED = "STOPPED",
+    STOPPING = "STOPPING",
+    SUSPENDED = "SUSPENDED",
+    TERMINATED = "TERMINATED",
+    TERMINATING = "TERMINATING",
+    UNHEALTHY = "UNHEALTHY",
+    UPDATING = "UPDATING"
+}
+
+export interface Workspace {
+    
+    WorkspaceId?: string;
+    
+    DirectoryId?: string;
+    
+    UserName?: string;
+    
+    IpAddress?: string;
+    
+    State?: WorkspaceState | string;
+    
+    BundleId?: string;
+    
+    SubnetId?: string;
+    
+    ErrorMessage?: string;
+    
+    ErrorCode?: string;
+    
+    ComputerName?: string;
+    
+    VolumeEncryptionKey?: string;
+    
+    UserVolumeEncryptionEnabled?: boolean;
+    
+    RootVolumeEncryptionEnabled?: boolean;
+    
+    WorkspaceProperties?: WorkspaceProperties;
+    
+    ModificationStates?: ModificationState[];
+}
+export declare namespace Workspace {
+    
+    const filterSensitiveLog: (obj: Workspace) => any;
+}
+export interface CreateWorkspacesResult {
+    
+    FailedRequests?: FailedCreateWorkspaceRequest[];
+    
+    PendingRequests?: Workspace[];
+}
+export declare namespace CreateWorkspacesResult {
+    
+    const filterSensitiveLog: (obj: CreateWorkspacesResult) => any;
+}
+export declare enum DedicatedTenancySupportEnum {
+    ENABLED = "ENABLED"
+}
+
+export interface DefaultWorkspaceCreationProperties {
+    
+    EnableWorkDocs?: boolean;
+    
+    EnableInternetAccess?: boolean;
+    
+    DefaultOu?: string;
+    
+    CustomSecurityGroupId?: string;
+    
+    UserEnabledAsLocalAdministrator?: boolean;
+    
+    EnableMaintenanceMode?: boolean;
+}
+export declare namespace DefaultWorkspaceCreationProperties {
+    
+    const filterSensitiveLog: (obj: DefaultWorkspaceCreationProperties) => any;
+}
+export interface DeleteConnectClientAddInRequest {
+    
+    AddInId: string | undefined;
+    
+    ResourceId: string | undefined;
+}
+export declare namespace DeleteConnectClientAddInRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConnectClientAddInRequest) => any;
+}
+export interface DeleteConnectClientAddInResult {
+}
+export declare namespace DeleteConnectClientAddInResult {
+    
+    const filterSensitiveLog: (obj: DeleteConnectClientAddInResult) => any;
+}
+export interface DeleteConnectionAliasRequest {
+    
+    AliasId: string | undefined;
+}
+export declare namespace DeleteConnectionAliasRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConnectionAliasRequest) => any;
+}
+export interface DeleteConnectionAliasResult {
+}
+export declare namespace DeleteConnectionAliasResult {
+    
+    const filterSensitiveLog: (obj: DeleteConnectionAliasResult) => any;
+}
+export interface DeleteIpGroupRequest {
+    
+    GroupId: string | undefined;
+}
+export declare namespace DeleteIpGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteIpGroupRequest) => any;
+}
+export interface DeleteIpGroupResult {
+}
+export declare namespace DeleteIpGroupResult {
+    
+    const filterSensitiveLog: (obj: DeleteIpGroupResult) => any;
+}
+export interface DeleteTagsRequest {
+    
+    ResourceId: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace DeleteTagsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTagsRequest) => any;
+}
+export interface DeleteTagsResult {
+}
+export declare namespace DeleteTagsResult {
+    
+    const filterSensitiveLog: (obj: DeleteTagsResult) => any;
+}
+export interface DeleteWorkspaceBundleRequest {
+    
+    BundleId?: string;
+}
+export declare namespace DeleteWorkspaceBundleRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWorkspaceBundleRequest) => any;
+}
+export interface DeleteWorkspaceBundleResult {
+}
+export declare namespace DeleteWorkspaceBundleResult {
+    
+    const filterSensitiveLog: (obj: DeleteWorkspaceBundleResult) => any;
+}
+export interface DeleteWorkspaceImageRequest {
+    
+    ImageId: string | undefined;
+}
+export declare namespace DeleteWorkspaceImageRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWorkspaceImageRequest) => any;
+}
+export interface DeleteWorkspaceImageResult {
+}
+export declare namespace DeleteWorkspaceImageResult {
+    
+    const filterSensitiveLog: (obj: DeleteWorkspaceImageResult) => any;
+}
+export interface DeregisterWorkspaceDirectoryRequest {
+    
+    DirectoryId: string | undefined;
+}
+export declare namespace DeregisterWorkspaceDirectoryRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterWorkspaceDirectoryRequest) => any;
+}
+export interface DeregisterWorkspaceDirectoryResult {
+}
+export declare namespace DeregisterWorkspaceDirectoryResult {
+    
+    const filterSensitiveLog: (obj: DeregisterWorkspaceDirectoryResult) => any;
+}
+export interface DescribeAccountRequest {
+}
+export declare namespace DescribeAccountRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAccountRequest) => any;
+}
+export interface DescribeAccountResult {
+    
+    DedicatedTenancySupport?: DedicatedTenancySupportResultEnum | string;
+    
+    DedicatedTenancyManagementCidrRange?: string;
+}
+export declare namespace DescribeAccountResult {
+    
+    const filterSensitiveLog: (obj: DescribeAccountResult) => any;
+}
+export interface DescribeAccountModificationsRequest {
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAccountModificationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAccountModificationsRequest) => any;
+}
+export interface DescribeAccountModificationsResult {
+    
+    AccountModifications?: AccountModification[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeAccountModificationsResult {
+    
+    const filterSensitiveLog: (obj: DescribeAccountModificationsResult) => any;
+}
+export interface DescribeClientPropertiesRequest {
+    
+    ResourceIds: string[] | undefined;
+}
+export declare namespace DescribeClientPropertiesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeClientPropertiesRequest) => any;
+}
+export interface DescribeClientPropertiesResult {
+    
+    ClientPropertiesList?: ClientPropertiesResult[];
+}
+export declare namespace DescribeClientPropertiesResult {
+    
+    const filterSensitiveLog: (obj: DescribeClientPropertiesResult) => any;
+}
+export interface DescribeConnectClientAddInsRequest {
+    
+    ResourceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeConnectClientAddInsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConnectClientAddInsRequest) => any;
+}
+export interface DescribeConnectClientAddInsResult {
+    
+    AddIns?: ConnectClientAddIn[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConnectClientAddInsResult {
+    
+    const filterSensitiveLog: (obj: DescribeConnectClientAddInsResult) => any;
+}
+export interface DescribeConnectionAliasesRequest {
+    
+    AliasIds?: string[];
+    
+    ResourceId?: string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConnectionAliasesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConnectionAliasesRequest) => any;
+}
+export interface DescribeConnectionAliasesResult {
+    
+    ConnectionAliases?: ConnectionAlias[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConnectionAliasesResult {
+    
+    const filterSensitiveLog: (obj: DescribeConnectionAliasesResult) => any;
+}
+export interface DescribeConnectionAliasPermissionsRequest {
+    
+    AliasId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeConnectionAliasPermissionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeConnectionAliasPermissionsRequest) => any;
+}
+export interface DescribeConnectionAliasPermissionsResult {
+    
+    AliasId?: string;
+    
+    ConnectionAliasPermissions?: ConnectionAliasPermission[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeConnectionAliasPermissionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeConnectionAliasPermissionsResult) => any;
+}
+export interface DescribeIpGroupsRequest {
+    
+    GroupIds?: string[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeIpGroupsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeIpGroupsRequest) => any;
+}
+
+export interface WorkspacesIpGroup {
+    
+    groupId?: string;
+    
+    groupName?: string;
+    
+    groupDesc?: string;
+    
+    userRules?: IpRuleItem[];
+}
+export declare namespace WorkspacesIpGroup {
+    
+    const filterSensitiveLog: (obj: WorkspacesIpGroup) => any;
+}
+export interface DescribeIpGroupsResult {
+    
+    Result?: WorkspacesIpGroup[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeIpGroupsResult {
+    
+    const filterSensitiveLog: (obj: DescribeIpGroupsResult) => any;
+}
+export interface DescribeTagsRequest {
+    
+    ResourceId: string | undefined;
+}
+export declare namespace DescribeTagsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeTagsRequest) => any;
+}
+export interface DescribeTagsResult {
+    
+    TagList?: Tag[];
+}
+export declare namespace DescribeTagsResult {
+    
+    const filterSensitiveLog: (obj: DescribeTagsResult) => any;
+}
+export interface DescribeWorkspaceBundlesRequest {
+    
+    BundleIds?: string[];
+    
+    Owner?: string;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeWorkspaceBundlesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspaceBundlesRequest) => any;
+}
+export interface DescribeWorkspaceBundlesResult {
+    
+    Bundles?: WorkspaceBundle[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeWorkspaceBundlesResult {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspaceBundlesResult) => any;
+}
+export interface DescribeWorkspaceDirectoriesRequest {
+    
+    DirectoryIds?: string[];
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeWorkspaceDirectoriesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspaceDirectoriesRequest) => any;
+}
+export declare enum WorkspaceDirectoryType {
+    AD_CONNECTOR = "AD_CONNECTOR",
+    SIMPLE_AD = "SIMPLE_AD"
+}
+
+export interface SelfservicePermissions {
+    
+    RestartWorkspace?: ReconnectEnum | string;
+    
+    IncreaseVolumeSize?: ReconnectEnum | string;
+    
+    ChangeComputeType?: ReconnectEnum | string;
+    
+    SwitchRunningMode?: ReconnectEnum | string;
+    
+    RebuildWorkspace?: ReconnectEnum | string;
+}
+export declare namespace SelfservicePermissions {
+    
+    const filterSensitiveLog: (obj: SelfservicePermissions) => any;
+}
+export declare enum WorkspaceDirectoryState {
+    DEREGISTERED = "DEREGISTERED",
+    DEREGISTERING = "DEREGISTERING",
+    ERROR = "ERROR",
+    REGISTERED = "REGISTERED",
+    REGISTERING = "REGISTERING"
+}
+export declare enum Tenancy {
+    DEDICATED = "DEDICATED",
+    SHARED = "SHARED"
+}
+
+export interface WorkspaceAccessProperties {
+    
+    DeviceTypeWindows?: AccessPropertyValue | string;
+    
+    DeviceTypeOsx?: AccessPropertyValue | string;
+    
+    DeviceTypeWeb?: AccessPropertyValue | string;
+    
+    DeviceTypeIos?: AccessPropertyValue | string;
+    
+    DeviceTypeAndroid?: AccessPropertyValue | string;
+    
+    DeviceTypeChromeOs?: AccessPropertyValue | string;
+    
+    DeviceTypeZeroClient?: AccessPropertyValue | string;
+    
+    DeviceTypeLinux?: AccessPropertyValue | string;
+}
+export declare namespace WorkspaceAccessProperties {
+    
+    const filterSensitiveLog: (obj: WorkspaceAccessProperties) => any;
+}
+
+export interface WorkspaceDirectory {
+    
+    DirectoryId?: string;
+    
+    Alias?: string;
+    
+    DirectoryName?: string;
+    
+    RegistrationCode?: string;
+    
+    SubnetIds?: string[];
+    
+    DnsIpAddresses?: string[];
+    
+    CustomerUserName?: string;
+    
+    IamRoleId?: string;
+    
+    DirectoryType?: WorkspaceDirectoryType | string;
+    
+    WorkspaceSecurityGroupId?: string;
+    
+    State?: WorkspaceDirectoryState | string;
+    
+    WorkspaceCreationProperties?: DefaultWorkspaceCreationProperties;
+    
+    ipGroupIds?: string[];
+    
+    WorkspaceAccessProperties?: WorkspaceAccessProperties;
+    
+    Tenancy?: Tenancy | string;
+    
+    SelfservicePermissions?: SelfservicePermissions;
+}
+export declare namespace WorkspaceDirectory {
+    
+    const filterSensitiveLog: (obj: WorkspaceDirectory) => any;
+}
+export interface DescribeWorkspaceDirectoriesResult {
+    
+    Directories?: WorkspaceDirectory[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeWorkspaceDirectoriesResult {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspaceDirectoriesResult) => any;
+}
+export interface DescribeWorkspaceImagePermissionsRequest {
+    
+    ImageId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeWorkspaceImagePermissionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspaceImagePermissionsRequest) => any;
+}
+
+export interface ImagePermission {
+    
+    SharedAccountId?: string;
+}
+export declare namespace ImagePermission {
+    
+    const filterSensitiveLog: (obj: ImagePermission) => any;
+}
+export interface DescribeWorkspaceImagePermissionsResult {
+    
+    ImageId?: string;
+    
+    ImagePermissions?: ImagePermission[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeWorkspaceImagePermissionsResult {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspaceImagePermissionsResult) => any;
+}
+export declare enum ImageType {
+    OWNED = "OWNED",
+    SHARED = "SHARED"
+}
+export interface DescribeWorkspaceImagesRequest {
+    
+    ImageIds?: string[];
+    
+    ImageType?: ImageType | string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeWorkspaceImagesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspaceImagesRequest) => any;
+}
+export declare enum OperatingSystemType {
+    LINUX = "LINUX",
+    WINDOWS = "WINDOWS"
+}
+
+export interface OperatingSystem {
+    
+    Type?: OperatingSystemType | string;
+}
+export declare namespace OperatingSystem {
+    
+    const filterSensitiveLog: (obj: OperatingSystem) => any;
+}
+export declare enum WorkspaceImageRequiredTenancy {
+    DEDICATED = "DEDICATED",
+    DEFAULT = "DEFAULT"
+}
+export declare enum WorkspaceImageState {
+    AVAILABLE = "AVAILABLE",
+    ERROR = "ERROR",
+    PENDING = "PENDING"
+}
+
+export interface UpdateResult {
+    
+    UpdateAvailable?: boolean;
+    
+    Description?: string;
+}
+export declare namespace UpdateResult {
+    
+    const filterSensitiveLog: (obj: UpdateResult) => any;
+}
+
+export interface WorkspaceImage {
+    
+    ImageId?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    OperatingSystem?: OperatingSystem;
+    
+    State?: WorkspaceImageState | string;
+    
+    RequiredTenancy?: WorkspaceImageRequiredTenancy | string;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+    
+    Created?: Date;
+    
+    OwnerAccountId?: string;
+    
+    Updates?: UpdateResult;
+}
+export declare namespace WorkspaceImage {
+    
+    const filterSensitiveLog: (obj: WorkspaceImage) => any;
+}
+export interface DescribeWorkspaceImagesResult {
+    
+    Images?: WorkspaceImage[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeWorkspaceImagesResult {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspaceImagesResult) => any;
+}
+export interface DescribeWorkspacesRequest {
+    
+    WorkspaceIds?: string[];
+    
+    DirectoryId?: string;
+    
+    UserName?: string;
+    
+    BundleId?: string;
+    
+    Limit?: number;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeWorkspacesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspacesRequest) => any;
+}
+export interface DescribeWorkspacesResult {
+    
+    Workspaces?: Workspace[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeWorkspacesResult {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspacesResult) => any;
+}
+export interface DescribeWorkspacesConnectionStatusRequest {
+    
+    WorkspaceIds?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeWorkspacesConnectionStatusRequest {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspacesConnectionStatusRequest) => any;
+}
+
+export interface WorkspaceConnectionStatus {
+    
+    WorkspaceId?: string;
+    
+    ConnectionState?: ConnectionState | string;
+    
+    ConnectionStateCheckTimestamp?: Date;
+    
+    LastKnownUserConnectionTimestamp?: Date;
+}
+export declare namespace WorkspaceConnectionStatus {
+    
+    const filterSensitiveLog: (obj: WorkspaceConnectionStatus) => any;
+}
+export interface DescribeWorkspacesConnectionStatusResult {
+    
+    WorkspacesConnectionStatus?: WorkspaceConnectionStatus[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeWorkspacesConnectionStatusResult {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspacesConnectionStatusResult) => any;
+}
+export interface DescribeWorkspaceSnapshotsRequest {
+    
+    WorkspaceId: string | undefined;
+}
+export declare namespace DescribeWorkspaceSnapshotsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspaceSnapshotsRequest) => any;
+}
+
+export interface Snapshot {
+    
+    SnapshotTime?: Date;
+}
+export declare namespace Snapshot {
+    
+    const filterSensitiveLog: (obj: Snapshot) => any;
+}
+export interface DescribeWorkspaceSnapshotsResult {
+    
+    RebuildSnapshots?: Snapshot[];
+    
+    RestoreSnapshots?: Snapshot[];
+}
+export declare namespace DescribeWorkspaceSnapshotsResult {
+    
+    const filterSensitiveLog: (obj: DescribeWorkspaceSnapshotsResult) => any;
+}
+export interface DisassociateConnectionAliasRequest {
+    
+    AliasId: string | undefined;
+}
+export declare namespace DisassociateConnectionAliasRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateConnectionAliasRequest) => any;
+}
+export interface DisassociateConnectionAliasResult {
+}
+export declare namespace DisassociateConnectionAliasResult {
+    
+    const filterSensitiveLog: (obj: DisassociateConnectionAliasResult) => any;
+}
+export interface DisassociateIpGroupsRequest {
+    
+    DirectoryId: string | undefined;
+    
+    GroupIds: string[] | undefined;
+}
+export declare namespace DisassociateIpGroupsRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateIpGroupsRequest) => any;
+}
+export interface DisassociateIpGroupsResult {
+}
+export declare namespace DisassociateIpGroupsResult {
+    
+    const filterSensitiveLog: (obj: DisassociateIpGroupsResult) => any;
+}
+
+export interface FailedWorkspaceChangeRequest {
+    
+    WorkspaceId?: string;
+    
+    ErrorCode?: string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace FailedWorkspaceChangeRequest {
+    
+    const filterSensitiveLog: (obj: FailedWorkspaceChangeRequest) => any;
+}
+export declare enum WorkspaceImageIngestionProcess {
+    BYOL_GRAPHICS = "BYOL_GRAPHICS",
+    BYOL_GRAPHICSPRO = "BYOL_GRAPHICSPRO",
+    BYOL_REGULAR = "BYOL_REGULAR",
+    BYOL_REGULAR_WSP = "BYOL_REGULAR_WSP"
+}
+export interface ImportWorkspaceImageRequest {
+    
+    Ec2ImageId: string | undefined;
+    
+    IngestionProcess: WorkspaceImageIngestionProcess | string | undefined;
+    
+    ImageName: string | undefined;
+    
+    ImageDescription: string | undefined;
+    
+    Tags?: Tag[];
+    
+    Applications?: (Application | string)[];
+}
+export declare namespace ImportWorkspaceImageRequest {
+    
+    const filterSensitiveLog: (obj: ImportWorkspaceImageRequest) => any;
+}
+export interface ImportWorkspaceImageResult {
+    
+    ImageId?: string;
+}
+export declare namespace ImportWorkspaceImageResult {
+    
+    const filterSensitiveLog: (obj: ImportWorkspaceImageResult) => any;
+}
+export interface ListAvailableManagementCidrRangesRequest {
+    
+    ManagementCidrRangeConstraint: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListAvailableManagementCidrRangesRequest {
+    
+    const filterSensitiveLog: (obj: ListAvailableManagementCidrRangesRequest) => any;
+}
+export interface ListAvailableManagementCidrRangesResult {
+    
+    ManagementCidrRanges?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAvailableManagementCidrRangesResult {
+    
+    const filterSensitiveLog: (obj: ListAvailableManagementCidrRangesResult) => any;
+}
+export interface MigrateWorkspaceRequest {
+    
+    SourceWorkspaceId: string | undefined;
+    
+    BundleId: string | undefined;
+}
+export declare namespace MigrateWorkspaceRequest {
+    
+    const filterSensitiveLog: (obj: MigrateWorkspaceRequest) => any;
+}
+export interface MigrateWorkspaceResult {
+    
+    SourceWorkspaceId?: string;
+    
+    TargetWorkspaceId?: string;
+}
+export declare namespace MigrateWorkspaceResult {
+    
+    const filterSensitiveLog: (obj: MigrateWorkspaceResult) => any;
+}
+
+export declare class OperationInProgressException extends __BaseException {
+    readonly name: "OperationInProgressException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OperationInProgressException, __BaseException>);
+}
+export interface ModifyAccountRequest {
+    
+    DedicatedTenancySupport?: DedicatedTenancySupportEnum | string;
+    
+    DedicatedTenancyManagementCidrRange?: string;
+}
+export declare namespace ModifyAccountRequest {
+    
+    const filterSensitiveLog: (obj: ModifyAccountRequest) => any;
+}
+export interface ModifyAccountResult {
+}
+export declare namespace ModifyAccountResult {
+    
+    const filterSensitiveLog: (obj: ModifyAccountResult) => any;
+}
+export interface ModifyClientPropertiesRequest {
+    
+    ResourceId: string | undefined;
+    
+    ClientProperties: ClientProperties | undefined;
+}
+export declare namespace ModifyClientPropertiesRequest {
+    
+    const filterSensitiveLog: (obj: ModifyClientPropertiesRequest) => any;
+}
+export interface ModifyClientPropertiesResult {
+}
+export declare namespace ModifyClientPropertiesResult {
+    
+    const filterSensitiveLog: (obj: ModifyClientPropertiesResult) => any;
+}
+export interface ModifySelfservicePermissionsRequest {
+    
+    ResourceId: string | undefined;
+    
+    SelfservicePermissions: SelfservicePermissions | undefined;
+}
+export declare namespace ModifySelfservicePermissionsRequest {
+    
+    const filterSensitiveLog: (obj: ModifySelfservicePermissionsRequest) => any;
+}
+export interface ModifySelfservicePermissionsResult {
+}
+export declare namespace ModifySelfservicePermissionsResult {
+    
+    const filterSensitiveLog: (obj: ModifySelfservicePermissionsResult) => any;
+}
+export interface ModifyWorkspaceAccessPropertiesRequest {
+    
+    ResourceId: string | undefined;
+    
+    WorkspaceAccessProperties: WorkspaceAccessProperties | undefined;
+}
+export declare namespace ModifyWorkspaceAccessPropertiesRequest {
+    
+    const filterSensitiveLog: (obj: ModifyWorkspaceAccessPropertiesRequest) => any;
+}
+export interface ModifyWorkspaceAccessPropertiesResult {
+}
+export declare namespace ModifyWorkspaceAccessPropertiesResult {
+    
+    const filterSensitiveLog: (obj: ModifyWorkspaceAccessPropertiesResult) => any;
+}
+
+export interface WorkspaceCreationProperties {
+    
+    EnableWorkDocs?: boolean;
+    
+    EnableInternetAccess?: boolean;
+    
+    DefaultOu?: string;
+    
+    CustomSecurityGroupId?: string;
+    
+    UserEnabledAsLocalAdministrator?: boolean;
+    
+    EnableMaintenanceMode?: boolean;
+}
+export declare namespace WorkspaceCreationProperties {
+    
+    const filterSensitiveLog: (obj: WorkspaceCreationProperties) => any;
+}
+export interface ModifyWorkspaceCreationPropertiesRequest {
+    
+    ResourceId: string | undefined;
+    
+    WorkspaceCreationProperties: WorkspaceCreationProperties | undefined;
+}
+export declare namespace ModifyWorkspaceCreationPropertiesRequest {
+    
+    const filterSensitiveLog: (obj: ModifyWorkspaceCreationPropertiesRequest) => any;
+}
+export interface ModifyWorkspaceCreationPropertiesResult {
+}
+export declare namespace ModifyWorkspaceCreationPropertiesResult {
+    
+    const filterSensitiveLog: (obj: ModifyWorkspaceCreationPropertiesResult) => any;
+}
+export interface ModifyWorkspacePropertiesRequest {
+    
+    WorkspaceId: string | undefined;
+    
+    WorkspaceProperties: WorkspaceProperties | undefined;
+}
+export declare namespace ModifyWorkspacePropertiesRequest {
+    
+    const filterSensitiveLog: (obj: ModifyWorkspacePropertiesRequest) => any;
+}
+export interface ModifyWorkspacePropertiesResult {
+}
+export declare namespace ModifyWorkspacePropertiesResult {
+    
+    const filterSensitiveLog: (obj: ModifyWorkspacePropertiesResult) => any;
+}
+
+export declare class UnsupportedWorkspaceConfigurationException extends __BaseException {
+    readonly name: "UnsupportedWorkspaceConfigurationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedWorkspaceConfigurationException, __BaseException>);
+}
+export declare enum TargetWorkspaceState {
+    ADMIN_MAINTENANCE = "ADMIN_MAINTENANCE",
+    AVAILABLE = "AVAILABLE"
+}
+export interface ModifyWorkspaceStateRequest {
+    
+    WorkspaceId: string | undefined;
+    
+    WorkspaceState: TargetWorkspaceState | string | undefined;
+}
+export declare namespace ModifyWorkspaceStateRequest {
+    
+    const filterSensitiveLog: (obj: ModifyWorkspaceStateRequest) => any;
+}
+export interface ModifyWorkspaceStateResult {
+}
+export declare namespace ModifyWorkspaceStateResult {
+    
+    const filterSensitiveLog: (obj: ModifyWorkspaceStateResult) => any;
+}
+
+export interface RebootRequest {
+    
+    WorkspaceId: string | undefined;
+}
+export declare namespace RebootRequest {
+    
+    const filterSensitiveLog: (obj: RebootRequest) => any;
+}
+export interface RebootWorkspacesRequest {
+    
+    RebootWorkspaceRequests: RebootRequest[] | undefined;
+}
+export declare namespace RebootWorkspacesRequest {
+    
+    const filterSensitiveLog: (obj: RebootWorkspacesRequest) => any;
+}
+export interface RebootWorkspacesResult {
+    
+    FailedRequests?: FailedWorkspaceChangeRequest[];
+}
+export declare namespace RebootWorkspacesResult {
+    
+    const filterSensitiveLog: (obj: RebootWorkspacesResult) => any;
+}
+
+export interface RebuildRequest {
+    
+    WorkspaceId: string | undefined;
+}
+export declare namespace RebuildRequest {
+    
+    const filterSensitiveLog: (obj: RebuildRequest) => any;
+}
+export interface RebuildWorkspacesRequest {
+    
+    RebuildWorkspaceRequests: RebuildRequest[] | undefined;
+}
+export declare namespace RebuildWorkspacesRequest {
+    
+    const filterSensitiveLog: (obj: RebuildWorkspacesRequest) => any;
+}
+export interface RebuildWorkspacesResult {
+    
+    FailedRequests?: FailedWorkspaceChangeRequest[];
+}
+export declare namespace RebuildWorkspacesResult {
+    
+    const filterSensitiveLog: (obj: RebuildWorkspacesResult) => any;
+}
+export interface RegisterWorkspaceDirectoryRequest {
+    
+    DirectoryId: string | undefined;
+    
+    SubnetIds?: string[];
+    
+    EnableWorkDocs: boolean | undefined;
+    
+    EnableSelfService?: boolean;
+    
+    Tenancy?: Tenancy | string;
+    
+    Tags?: Tag[];
+}
+export declare namespace RegisterWorkspaceDirectoryRequest {
+    
+    const filterSensitiveLog: (obj: RegisterWorkspaceDirectoryRequest) => any;
+}
+export interface RegisterWorkspaceDirectoryResult {
+}
+export declare namespace RegisterWorkspaceDirectoryResult {
+    
+    const filterSensitiveLog: (obj: RegisterWorkspaceDirectoryResult) => any;
+}
+
+export declare class UnsupportedNetworkConfigurationException extends __BaseException {
+    readonly name: "UnsupportedNetworkConfigurationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedNetworkConfigurationException, __BaseException>);
+}
+
+export declare class WorkspacesDefaultRoleNotFoundException extends __BaseException {
+    readonly name: "WorkspacesDefaultRoleNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<WorkspacesDefaultRoleNotFoundException, __BaseException>);
+}
+export interface RestoreWorkspaceRequest {
+    
+    WorkspaceId: string | undefined;
+}
+export declare namespace RestoreWorkspaceRequest {
+    
+    const filterSensitiveLog: (obj: RestoreWorkspaceRequest) => any;
+}
+export interface RestoreWorkspaceResult {
+}
+export declare namespace RestoreWorkspaceResult {
+    
+    const filterSensitiveLog: (obj: RestoreWorkspaceResult) => any;
+}
+export interface RevokeIpRulesRequest {
+    
+    GroupId: string | undefined;
+    
+    UserRules: string[] | undefined;
+}
+export declare namespace RevokeIpRulesRequest {
+    
+    const filterSensitiveLog: (obj: RevokeIpRulesRequest) => any;
+}
+export interface RevokeIpRulesResult {
+}
+export declare namespace RevokeIpRulesResult {
+    
+    const filterSensitiveLog: (obj: RevokeIpRulesResult) => any;
+}
+
+export interface StartRequest {
+    
+    WorkspaceId?: string;
+}
+export declare namespace StartRequest {
+    
+    const filterSensitiveLog: (obj: StartRequest) => any;
+}
+export interface StartWorkspacesRequest {
+    
+    StartWorkspaceRequests: StartRequest[] | undefined;
+}
+export declare namespace StartWorkspacesRequest {
+    
+    const filterSensitiveLog: (obj: StartWorkspacesRequest) => any;
+}
+export interface StartWorkspacesResult {
+    
+    FailedRequests?: FailedWorkspaceChangeRequest[];
+}
+export declare namespace StartWorkspacesResult {
+    
+    const filterSensitiveLog: (obj: StartWorkspacesResult) => any;
+}
+
+export interface StopRequest {
+    
+    WorkspaceId?: string;
+}
+export declare namespace StopRequest {
+    
+    const filterSensitiveLog: (obj: StopRequest) => any;
+}
+export interface StopWorkspacesRequest {
+    
+    StopWorkspaceRequests: StopRequest[] | undefined;
+}
+export declare namespace StopWorkspacesRequest {
+    
+    const filterSensitiveLog: (obj: StopWorkspacesRequest) => any;
+}
+export interface StopWorkspacesResult {
+    
+    FailedRequests?: FailedWorkspaceChangeRequest[];
+}
+export declare namespace StopWorkspacesResult {
+    
+    const filterSensitiveLog: (obj: StopWorkspacesResult) => any;
+}
+
+export interface TerminateRequest {
+    
+    WorkspaceId: string | undefined;
+}
+export declare namespace TerminateRequest {
+    
+    const filterSensitiveLog: (obj: TerminateRequest) => any;
+}
+export interface TerminateWorkspacesRequest {
+    
+    TerminateWorkspaceRequests: TerminateRequest[] | undefined;
+}
+export declare namespace TerminateWorkspacesRequest {
+    
+    const filterSensitiveLog: (obj: TerminateWorkspacesRequest) => any;
+}
+export interface TerminateWorkspacesResult {
+    
+    FailedRequests?: FailedWorkspaceChangeRequest[];
+}
+export declare namespace TerminateWorkspacesResult {
+    
+    const filterSensitiveLog: (obj: TerminateWorkspacesResult) => any;
+}
+export interface UpdateConnectClientAddInRequest {
+    
+    AddInId: string | undefined;
+    
+    ResourceId: string | undefined;
+    
+    Name?: string;
+    
+    URL?: string;
+}
+export declare namespace UpdateConnectClientAddInRequest {
+    
+    const filterSensitiveLog: (obj: UpdateConnectClientAddInRequest) => any;
+}
+export interface UpdateConnectClientAddInResult {
+}
+export declare namespace UpdateConnectClientAddInResult {
+    
+    const filterSensitiveLog: (obj: UpdateConnectClientAddInResult) => any;
+}
+export interface UpdateConnectionAliasPermissionRequest {
+    
+    AliasId: string | undefined;
+    
+    ConnectionAliasPermission: ConnectionAliasPermission | undefined;
+}
+export declare namespace UpdateConnectionAliasPermissionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionAliasPermissionRequest) => any;
+}
+export interface UpdateConnectionAliasPermissionResult {
+}
+export declare namespace UpdateConnectionAliasPermissionResult {
+    
+    const filterSensitiveLog: (obj: UpdateConnectionAliasPermissionResult) => any;
+}
+export interface UpdateRulesOfIpGroupRequest {
+    
+    GroupId: string | undefined;
+    
+    UserRules: IpRuleItem[] | undefined;
+}
+export declare namespace UpdateRulesOfIpGroupRequest {
+    
+    const filterSensitiveLog: (obj: UpdateRulesOfIpGroupRequest) => any;
+}
+export interface UpdateRulesOfIpGroupResult {
+}
+export declare namespace UpdateRulesOfIpGroupResult {
+    
+    const filterSensitiveLog: (obj: UpdateRulesOfIpGroupResult) => any;
+}
+export interface UpdateWorkspaceBundleRequest {
+    
+    BundleId?: string;
+    
+    ImageId?: string;
+}
+export declare namespace UpdateWorkspaceBundleRequest {
+    
+    const filterSensitiveLog: (obj: UpdateWorkspaceBundleRequest) => any;
+}
+export interface UpdateWorkspaceBundleResult {
+}
+export declare namespace UpdateWorkspaceBundleResult {
+    
+    const filterSensitiveLog: (obj: UpdateWorkspaceBundleResult) => any;
+}
+export interface UpdateWorkspaceImagePermissionRequest {
+    
+    ImageId: string | undefined;
+    
+    AllowCopyImage: boolean | undefined;
+    
+    SharedAccountId: string | undefined;
+}
+export declare namespace UpdateWorkspaceImagePermissionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateWorkspaceImagePermissionRequest) => any;
+}
+export interface UpdateWorkspaceImagePermissionResult {
+}
+export declare namespace UpdateWorkspaceImagePermissionResult {
+    
+    const filterSensitiveLog: (obj: UpdateWorkspaceImagePermissionResult) => any;
+}