@aws-sdk/client-transfer 3.34.0 → 3.37.0

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

@@ -0,0 +1,1344 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace AccessDeniedException {
+    
+    const filterSensitiveLog: (obj: AccessDeniedException) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    Message: string | undefined;
+}
+export declare namespace ConflictException {
+    
+    const filterSensitiveLog: (obj: ConflictException) => any;
+}
+
+export interface EfsFileLocation {
+    
+    FileSystemId?: string;
+    
+    Path?: string;
+}
+export declare namespace EfsFileLocation {
+    
+    const filterSensitiveLog: (obj: EfsFileLocation) => any;
+}
+
+export interface S3InputFileLocation {
+    
+    Bucket?: string;
+    
+    Key?: string;
+}
+export declare namespace S3InputFileLocation {
+    
+    const filterSensitiveLog: (obj: S3InputFileLocation) => any;
+}
+
+export interface InputFileLocation {
+    
+    S3FileLocation?: S3InputFileLocation;
+    
+    EfsFileLocation?: EfsFileLocation;
+}
+export declare namespace InputFileLocation {
+    
+    const filterSensitiveLog: (obj: InputFileLocation) => any;
+}
+export declare enum OverwriteExisting {
+    FALSE = "FALSE",
+    TRUE = "TRUE"
+}
+
+export interface CopyStepDetails {
+    
+    Name?: string;
+    
+    DestinationFileLocation?: InputFileLocation;
+    
+    OverwriteExisting?: OverwriteExisting | string;
+}
+export declare namespace CopyStepDetails {
+    
+    const filterSensitiveLog: (obj: CopyStepDetails) => any;
+}
+
+export interface HomeDirectoryMapEntry {
+    
+    Entry: string | undefined;
+    
+    Target: string | undefined;
+}
+export declare namespace HomeDirectoryMapEntry {
+    
+    const filterSensitiveLog: (obj: HomeDirectoryMapEntry) => any;
+}
+export declare enum HomeDirectoryType {
+    LOGICAL = "LOGICAL",
+    PATH = "PATH"
+}
+
+export interface PosixProfile {
+    
+    Uid: number | undefined;
+    
+    Gid: number | undefined;
+    
+    SecondaryGids?: number[];
+}
+export declare namespace PosixProfile {
+    
+    const filterSensitiveLog: (obj: PosixProfile) => any;
+}
+export interface CreateAccessRequest {
+    
+    HomeDirectory?: string;
+    
+    HomeDirectoryType?: HomeDirectoryType | string;
+    
+    HomeDirectoryMappings?: HomeDirectoryMapEntry[];
+    
+    Policy?: string;
+    
+    PosixProfile?: PosixProfile;
+    
+    Role: string | undefined;
+    
+    ServerId: string | undefined;
+    
+    ExternalId: string | undefined;
+}
+export declare namespace CreateAccessRequest {
+    
+    const filterSensitiveLog: (obj: CreateAccessRequest) => any;
+}
+export interface CreateAccessResponse {
+    
+    ServerId: string | undefined;
+    
+    ExternalId: string | undefined;
+}
+export declare namespace CreateAccessResponse {
+    
+    const filterSensitiveLog: (obj: CreateAccessResponse) => any;
+}
+
+export interface InternalServiceError extends __SmithyException, $MetadataBearer {
+    name: "InternalServiceError";
+    $fault: "server";
+    Message: string | undefined;
+}
+export declare namespace InternalServiceError {
+    
+    const filterSensitiveLog: (obj: InternalServiceError) => any;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    Message: string | undefined;
+}
+export declare namespace InvalidRequestException {
+    
+    const filterSensitiveLog: (obj: InvalidRequestException) => any;
+}
+
+export interface ResourceExistsException extends __SmithyException, $MetadataBearer {
+    name: "ResourceExistsException";
+    $fault: "client";
+    Message: string | undefined;
+    Resource: string | undefined;
+    ResourceType: string | undefined;
+}
+export declare namespace ResourceExistsException {
+    
+    const filterSensitiveLog: (obj: ResourceExistsException) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    Message: string | undefined;
+    Resource: string | undefined;
+    ResourceType: string | undefined;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+
+export interface ServiceUnavailableException extends __SmithyException, $MetadataBearer {
+    name: "ServiceUnavailableException";
+    $fault: "server";
+    Message?: string;
+}
+export declare namespace ServiceUnavailableException {
+    
+    const filterSensitiveLog: (obj: ServiceUnavailableException) => any;
+}
+export declare enum Domain {
+    EFS = "EFS",
+    S3 = "S3"
+}
+
+export interface EndpointDetails {
+    
+    AddressAllocationIds?: string[];
+    
+    SubnetIds?: string[];
+    
+    VpcEndpointId?: string;
+    
+    VpcId?: string;
+    
+    SecurityGroupIds?: string[];
+}
+export declare namespace EndpointDetails {
+    
+    const filterSensitiveLog: (obj: EndpointDetails) => any;
+}
+export declare enum EndpointType {
+    PUBLIC = "PUBLIC",
+    VPC = "VPC",
+    VPC_ENDPOINT = "VPC_ENDPOINT"
+}
+
+export interface IdentityProviderDetails {
+    
+    Url?: string;
+    
+    InvocationRole?: string;
+    
+    DirectoryId?: string;
+}
+export declare namespace IdentityProviderDetails {
+    
+    const filterSensitiveLog: (obj: IdentityProviderDetails) => any;
+}
+export declare enum IdentityProviderType {
+    API_GATEWAY = "API_GATEWAY",
+    AWS_DIRECTORY_SERVICE = "AWS_DIRECTORY_SERVICE",
+    SERVICE_MANAGED = "SERVICE_MANAGED"
+}
+export declare enum Protocol {
+    FTP = "FTP",
+    FTPS = "FTPS",
+    SFTP = "SFTP"
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+
+export interface WorkflowDetail {
+    
+    WorkflowId: string | undefined;
+    
+    ExecutionRole: string | undefined;
+}
+export declare namespace WorkflowDetail {
+    
+    const filterSensitiveLog: (obj: WorkflowDetail) => any;
+}
+
+export interface WorkflowDetails {
+    
+    OnUpload: WorkflowDetail[] | undefined;
+}
+export declare namespace WorkflowDetails {
+    
+    const filterSensitiveLog: (obj: WorkflowDetails) => any;
+}
+export interface CreateServerRequest {
+    
+    Certificate?: string;
+    
+    Domain?: Domain | string;
+    
+    EndpointDetails?: EndpointDetails;
+    
+    EndpointType?: EndpointType | string;
+    
+    HostKey?: string;
+    
+    IdentityProviderDetails?: IdentityProviderDetails;
+    
+    IdentityProviderType?: IdentityProviderType | string;
+    
+    LoggingRole?: string;
+    
+    Protocols?: (Protocol | string)[];
+    
+    SecurityPolicyName?: string;
+    
+    Tags?: Tag[];
+    
+    WorkflowDetails?: WorkflowDetails;
+}
+export declare namespace CreateServerRequest {
+    
+    const filterSensitiveLog: (obj: CreateServerRequest) => any;
+}
+export interface CreateServerResponse {
+    
+    ServerId: string | undefined;
+}
+export declare namespace CreateServerResponse {
+    
+    const filterSensitiveLog: (obj: CreateServerResponse) => any;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    RetryAfterSeconds?: string;
+}
+export declare namespace ThrottlingException {
+    
+    const filterSensitiveLog: (obj: ThrottlingException) => any;
+}
+export interface CreateUserRequest {
+    
+    HomeDirectory?: string;
+    
+    HomeDirectoryType?: HomeDirectoryType | string;
+    
+    HomeDirectoryMappings?: HomeDirectoryMapEntry[];
+    
+    Policy?: string;
+    
+    PosixProfile?: PosixProfile;
+    
+    Role: string | undefined;
+    
+    ServerId: string | undefined;
+    
+    SshPublicKeyBody?: string;
+    
+    Tags?: Tag[];
+    
+    UserName: string | undefined;
+}
+export declare namespace CreateUserRequest {
+    
+    const filterSensitiveLog: (obj: CreateUserRequest) => any;
+}
+export interface CreateUserResponse {
+    
+    ServerId: string | undefined;
+    
+    UserName: string | undefined;
+}
+export declare namespace CreateUserResponse {
+    
+    const filterSensitiveLog: (obj: CreateUserResponse) => any;
+}
+
+export interface CustomStepDetails {
+    
+    Name?: string;
+    
+    Target?: string;
+    
+    TimeoutSeconds?: number;
+}
+export declare namespace CustomStepDetails {
+    
+    const filterSensitiveLog: (obj: CustomStepDetails) => any;
+}
+
+export interface DeleteStepDetails {
+    
+    Name?: string;
+}
+export declare namespace DeleteStepDetails {
+    
+    const filterSensitiveLog: (obj: DeleteStepDetails) => any;
+}
+
+export interface S3Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace S3Tag {
+    
+    const filterSensitiveLog: (obj: S3Tag) => any;
+}
+
+export interface TagStepDetails {
+    
+    Name?: string;
+    
+    Tags?: S3Tag[];
+}
+export declare namespace TagStepDetails {
+    
+    const filterSensitiveLog: (obj: TagStepDetails) => any;
+}
+export declare enum WorkflowStepType {
+    COPY = "COPY",
+    CUSTOM = "CUSTOM",
+    DELETE = "DELETE",
+    TAG = "TAG"
+}
+
+export interface WorkflowStep {
+    
+    Type?: WorkflowStepType | string;
+    
+    CopyStepDetails?: CopyStepDetails;
+    
+    CustomStepDetails?: CustomStepDetails;
+    
+    DeleteStepDetails?: DeleteStepDetails;
+    
+    TagStepDetails?: TagStepDetails;
+}
+export declare namespace WorkflowStep {
+    
+    const filterSensitiveLog: (obj: WorkflowStep) => any;
+}
+export interface CreateWorkflowRequest {
+    
+    Description?: string;
+    
+    Steps: WorkflowStep[] | undefined;
+    
+    OnExceptionSteps?: WorkflowStep[];
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateWorkflowRequest {
+    
+    const filterSensitiveLog: (obj: CreateWorkflowRequest) => any;
+}
+export interface CreateWorkflowResponse {
+    
+    WorkflowId: string | undefined;
+}
+export declare namespace CreateWorkflowResponse {
+    
+    const filterSensitiveLog: (obj: CreateWorkflowResponse) => any;
+}
+export declare enum CustomStepStatus {
+    FAILURE = "FAILURE",
+    SUCCESS = "SUCCESS"
+}
+export interface DeleteAccessRequest {
+    
+    ServerId: string | undefined;
+    
+    ExternalId: string | undefined;
+}
+export declare namespace DeleteAccessRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAccessRequest) => any;
+}
+export interface DeleteServerRequest {
+    
+    ServerId: string | undefined;
+}
+export declare namespace DeleteServerRequest {
+    
+    const filterSensitiveLog: (obj: DeleteServerRequest) => any;
+}
+export interface DeleteSshPublicKeyRequest {
+    
+    ServerId: string | undefined;
+    
+    SshPublicKeyId: string | undefined;
+    
+    UserName: string | undefined;
+}
+export declare namespace DeleteSshPublicKeyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSshPublicKeyRequest) => any;
+}
+export interface DeleteUserRequest {
+    
+    ServerId: string | undefined;
+    
+    UserName: string | undefined;
+}
+export declare namespace DeleteUserRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUserRequest) => any;
+}
+export interface DeleteWorkflowRequest {
+    
+    WorkflowId: string | undefined;
+}
+export declare namespace DeleteWorkflowRequest {
+    
+    const filterSensitiveLog: (obj: DeleteWorkflowRequest) => any;
+}
+export interface DescribeAccessRequest {
+    
+    ServerId: string | undefined;
+    
+    ExternalId: string | undefined;
+}
+export declare namespace DescribeAccessRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAccessRequest) => any;
+}
+
+export interface DescribedAccess {
+    
+    HomeDirectory?: string;
+    
+    HomeDirectoryMappings?: HomeDirectoryMapEntry[];
+    
+    HomeDirectoryType?: HomeDirectoryType | string;
+    
+    Policy?: string;
+    
+    PosixProfile?: PosixProfile;
+    
+    Role?: string;
+    
+    ExternalId?: string;
+}
+export declare namespace DescribedAccess {
+    
+    const filterSensitiveLog: (obj: DescribedAccess) => any;
+}
+export interface DescribeAccessResponse {
+    
+    ServerId: string | undefined;
+    
+    Access: DescribedAccess | undefined;
+}
+export declare namespace DescribeAccessResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAccessResponse) => any;
+}
+
+export interface S3FileLocation {
+    
+    Bucket?: string;
+    
+    Key?: string;
+    
+    VersionId?: string;
+    
+    Etag?: string;
+}
+export declare namespace S3FileLocation {
+    
+    const filterSensitiveLog: (obj: S3FileLocation) => any;
+}
+
+export interface FileLocation {
+    
+    S3FileLocation?: S3FileLocation;
+    
+    EfsFileLocation?: EfsFileLocation;
+}
+export declare namespace FileLocation {
+    
+    const filterSensitiveLog: (obj: FileLocation) => any;
+}
+
+export interface LoggingConfiguration {
+    
+    LoggingRole?: string;
+    
+    LogGroupName?: string;
+}
+export declare namespace LoggingConfiguration {
+    
+    const filterSensitiveLog: (obj: LoggingConfiguration) => any;
+}
+export declare enum ExecutionErrorType {
+    PERMISSION_DENIED = "PERMISSION_DENIED"
+}
+
+export interface ExecutionError {
+    
+    Type: ExecutionErrorType | string | undefined;
+    
+    Message: string | undefined;
+}
+export declare namespace ExecutionError {
+    
+    const filterSensitiveLog: (obj: ExecutionError) => any;
+}
+
+export interface ExecutionStepResult {
+    
+    StepType?: WorkflowStepType | string;
+    
+    Outputs?: string;
+    
+    Error?: ExecutionError;
+}
+export declare namespace ExecutionStepResult {
+    
+    const filterSensitiveLog: (obj: ExecutionStepResult) => any;
+}
+
+export interface ExecutionResults {
+    
+    Steps?: ExecutionStepResult[];
+    
+    OnExceptionSteps?: ExecutionStepResult[];
+}
+export declare namespace ExecutionResults {
+    
+    const filterSensitiveLog: (obj: ExecutionResults) => any;
+}
+
+export interface UserDetails {
+    
+    UserName: string | undefined;
+    
+    ServerId: string | undefined;
+    
+    SessionId?: string;
+}
+export declare namespace UserDetails {
+    
+    const filterSensitiveLog: (obj: UserDetails) => any;
+}
+
+export interface ServiceMetadata {
+    
+    UserDetails: UserDetails | undefined;
+}
+export declare namespace ServiceMetadata {
+    
+    const filterSensitiveLog: (obj: ServiceMetadata) => any;
+}
+export declare enum ExecutionStatus {
+    COMPLETED = "COMPLETED",
+    EXCEPTION = "EXCEPTION",
+    HANDLING_EXCEPTION = "HANDLING_EXCEPTION",
+    IN_PROGRESS = "IN_PROGRESS"
+}
+
+export interface DescribedExecution {
+    
+    ExecutionId?: string;
+    
+    InitialFileLocation?: FileLocation;
+    
+    ServiceMetadata?: ServiceMetadata;
+    
+    ExecutionRole?: string;
+    
+    LoggingConfiguration?: LoggingConfiguration;
+    
+    PosixProfile?: PosixProfile;
+    
+    Status?: ExecutionStatus | string;
+    
+    Results?: ExecutionResults;
+}
+export declare namespace DescribedExecution {
+    
+    const filterSensitiveLog: (obj: DescribedExecution) => any;
+}
+
+export interface DescribedSecurityPolicy {
+    
+    Fips?: boolean;
+    
+    SecurityPolicyName: string | undefined;
+    
+    SshCiphers?: string[];
+    
+    SshKexs?: string[];
+    
+    SshMacs?: string[];
+    
+    TlsCiphers?: string[];
+}
+export declare namespace DescribedSecurityPolicy {
+    
+    const filterSensitiveLog: (obj: DescribedSecurityPolicy) => any;
+}
+
+export interface ProtocolDetails {
+    
+    PassiveIp?: string;
+}
+export declare namespace ProtocolDetails {
+    
+    const filterSensitiveLog: (obj: ProtocolDetails) => any;
+}
+export declare enum State {
+    OFFLINE = "OFFLINE",
+    ONLINE = "ONLINE",
+    STARTING = "STARTING",
+    START_FAILED = "START_FAILED",
+    STOPPING = "STOPPING",
+    STOP_FAILED = "STOP_FAILED"
+}
+
+export interface DescribedServer {
+    
+    Arn: string | undefined;
+    
+    Certificate?: string;
+    
+    ProtocolDetails?: ProtocolDetails;
+    
+    Domain?: Domain | string;
+    
+    EndpointDetails?: EndpointDetails;
+    
+    EndpointType?: EndpointType | string;
+    
+    HostKeyFingerprint?: string;
+    
+    IdentityProviderDetails?: IdentityProviderDetails;
+    
+    IdentityProviderType?: IdentityProviderType | string;
+    
+    LoggingRole?: string;
+    
+    Protocols?: (Protocol | string)[];
+    
+    SecurityPolicyName?: string;
+    
+    ServerId?: string;
+    
+    State?: State | string;
+    
+    Tags?: Tag[];
+    
+    UserCount?: number;
+    
+    WorkflowDetails?: WorkflowDetails;
+}
+export declare namespace DescribedServer {
+    
+    const filterSensitiveLog: (obj: DescribedServer) => any;
+}
+
+export interface SshPublicKey {
+    
+    DateImported: Date | undefined;
+    
+    SshPublicKeyBody: string | undefined;
+    
+    SshPublicKeyId: string | undefined;
+}
+export declare namespace SshPublicKey {
+    
+    const filterSensitiveLog: (obj: SshPublicKey) => any;
+}
+
+export interface DescribedUser {
+    
+    Arn: string | undefined;
+    
+    HomeDirectory?: string;
+    
+    HomeDirectoryMappings?: HomeDirectoryMapEntry[];
+    
+    HomeDirectoryType?: HomeDirectoryType | string;
+    
+    Policy?: string;
+    
+    PosixProfile?: PosixProfile;
+    
+    Role?: string;
+    
+    SshPublicKeys?: SshPublicKey[];
+    
+    Tags?: Tag[];
+    
+    UserName?: string;
+}
+export declare namespace DescribedUser {
+    
+    const filterSensitiveLog: (obj: DescribedUser) => any;
+}
+
+export interface DescribedWorkflow {
+    
+    Arn: string | undefined;
+    
+    Description?: string;
+    
+    Steps?: WorkflowStep[];
+    
+    OnExceptionSteps?: WorkflowStep[];
+    
+    WorkflowId?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace DescribedWorkflow {
+    
+    const filterSensitiveLog: (obj: DescribedWorkflow) => any;
+}
+export interface DescribeExecutionRequest {
+    
+    ExecutionId: string | undefined;
+    
+    WorkflowId: string | undefined;
+}
+export declare namespace DescribeExecutionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeExecutionRequest) => any;
+}
+export interface DescribeExecutionResponse {
+    
+    WorkflowId: string | undefined;
+    
+    Execution: DescribedExecution | undefined;
+}
+export declare namespace DescribeExecutionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeExecutionResponse) => any;
+}
+export interface DescribeSecurityPolicyRequest {
+    
+    SecurityPolicyName: string | undefined;
+}
+export declare namespace DescribeSecurityPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DescribeSecurityPolicyRequest) => any;
+}
+export interface DescribeSecurityPolicyResponse {
+    
+    SecurityPolicy: DescribedSecurityPolicy | undefined;
+}
+export declare namespace DescribeSecurityPolicyResponse {
+    
+    const filterSensitiveLog: (obj: DescribeSecurityPolicyResponse) => any;
+}
+export interface DescribeServerRequest {
+    
+    ServerId: string | undefined;
+}
+export declare namespace DescribeServerRequest {
+    
+    const filterSensitiveLog: (obj: DescribeServerRequest) => any;
+}
+export interface DescribeServerResponse {
+    
+    Server: DescribedServer | undefined;
+}
+export declare namespace DescribeServerResponse {
+    
+    const filterSensitiveLog: (obj: DescribeServerResponse) => any;
+}
+export interface DescribeUserRequest {
+    
+    ServerId: string | undefined;
+    
+    UserName: string | undefined;
+}
+export declare namespace DescribeUserRequest {
+    
+    const filterSensitiveLog: (obj: DescribeUserRequest) => any;
+}
+export interface DescribeUserResponse {
+    
+    ServerId: string | undefined;
+    
+    User: DescribedUser | undefined;
+}
+export declare namespace DescribeUserResponse {
+    
+    const filterSensitiveLog: (obj: DescribeUserResponse) => any;
+}
+export interface DescribeWorkflowRequest {
+    
+    WorkflowId: string | undefined;
+}
+export declare namespace DescribeWorkflowRequest {
+    
+    const filterSensitiveLog: (obj: DescribeWorkflowRequest) => any;
+}
+export interface DescribeWorkflowResponse {
+    
+    Workflow: DescribedWorkflow | undefined;
+}
+export declare namespace DescribeWorkflowResponse {
+    
+    const filterSensitiveLog: (obj: DescribeWorkflowResponse) => any;
+}
+export interface ImportSshPublicKeyRequest {
+    
+    ServerId: string | undefined;
+    
+    SshPublicKeyBody: string | undefined;
+    
+    UserName: string | undefined;
+}
+export declare namespace ImportSshPublicKeyRequest {
+    
+    const filterSensitiveLog: (obj: ImportSshPublicKeyRequest) => any;
+}
+
+export interface ImportSshPublicKeyResponse {
+    
+    ServerId: string | undefined;
+    
+    SshPublicKeyId: string | undefined;
+    
+    UserName: string | undefined;
+}
+export declare namespace ImportSshPublicKeyResponse {
+    
+    const filterSensitiveLog: (obj: ImportSshPublicKeyResponse) => any;
+}
+
+export interface InvalidNextTokenException extends __SmithyException, $MetadataBearer {
+    name: "InvalidNextTokenException";
+    $fault: "client";
+    Message: string | undefined;
+}
+export declare namespace InvalidNextTokenException {
+    
+    const filterSensitiveLog: (obj: InvalidNextTokenException) => any;
+}
+export interface ListAccessesRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    ServerId: string | undefined;
+}
+export declare namespace ListAccessesRequest {
+    
+    const filterSensitiveLog: (obj: ListAccessesRequest) => any;
+}
+
+export interface ListedAccess {
+    
+    HomeDirectory?: string;
+    
+    HomeDirectoryType?: HomeDirectoryType | string;
+    
+    Role?: string;
+    
+    ExternalId?: string;
+}
+export declare namespace ListedAccess {
+    
+    const filterSensitiveLog: (obj: ListedAccess) => any;
+}
+export interface ListAccessesResponse {
+    
+    NextToken?: string;
+    
+    ServerId: string | undefined;
+    
+    Accesses: ListedAccess[] | undefined;
+}
+export declare namespace ListAccessesResponse {
+    
+    const filterSensitiveLog: (obj: ListAccessesResponse) => any;
+}
+
+export interface ListedExecution {
+    
+    ExecutionId?: string;
+    
+    InitialFileLocation?: FileLocation;
+    
+    ServiceMetadata?: ServiceMetadata;
+    
+    Status?: ExecutionStatus | string;
+}
+export declare namespace ListedExecution {
+    
+    const filterSensitiveLog: (obj: ListedExecution) => any;
+}
+
+export interface ListedServer {
+    
+    Arn: string | undefined;
+    
+    Domain?: Domain | string;
+    
+    IdentityProviderType?: IdentityProviderType | string;
+    
+    EndpointType?: EndpointType | string;
+    
+    LoggingRole?: string;
+    
+    ServerId?: string;
+    
+    State?: State | string;
+    
+    UserCount?: number;
+}
+export declare namespace ListedServer {
+    
+    const filterSensitiveLog: (obj: ListedServer) => any;
+}
+
+export interface ListedUser {
+    
+    Arn: string | undefined;
+    
+    HomeDirectory?: string;
+    
+    HomeDirectoryType?: HomeDirectoryType | string;
+    
+    Role?: string;
+    
+    SshPublicKeyCount?: number;
+    
+    UserName?: string;
+}
+export declare namespace ListedUser {
+    
+    const filterSensitiveLog: (obj: ListedUser) => any;
+}
+
+export interface ListedWorkflow {
+    
+    WorkflowId?: string;
+    
+    Description?: string;
+    
+    Arn?: string;
+}
+export declare namespace ListedWorkflow {
+    
+    const filterSensitiveLog: (obj: ListedWorkflow) => any;
+}
+export interface ListExecutionsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    WorkflowId: string | undefined;
+}
+export declare namespace ListExecutionsRequest {
+    
+    const filterSensitiveLog: (obj: ListExecutionsRequest) => any;
+}
+export interface ListExecutionsResponse {
+    
+    NextToken?: string;
+    
+    WorkflowId: string | undefined;
+    
+    Executions: ListedExecution[] | undefined;
+}
+export declare namespace ListExecutionsResponse {
+    
+    const filterSensitiveLog: (obj: ListExecutionsResponse) => any;
+}
+export interface ListSecurityPoliciesRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListSecurityPoliciesRequest {
+    
+    const filterSensitiveLog: (obj: ListSecurityPoliciesRequest) => any;
+}
+export interface ListSecurityPoliciesResponse {
+    
+    NextToken?: string;
+    
+    SecurityPolicyNames: string[] | undefined;
+}
+export declare namespace ListSecurityPoliciesResponse {
+    
+    const filterSensitiveLog: (obj: ListSecurityPoliciesResponse) => any;
+}
+export interface ListServersRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListServersRequest {
+    
+    const filterSensitiveLog: (obj: ListServersRequest) => any;
+}
+export interface ListServersResponse {
+    
+    NextToken?: string;
+    
+    Servers: ListedServer[] | undefined;
+}
+export declare namespace ListServersResponse {
+    
+    const filterSensitiveLog: (obj: ListServersResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    Arn: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Arn?: string;
+    
+    NextToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListUsersRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    ServerId: string | undefined;
+}
+export declare namespace ListUsersRequest {
+    
+    const filterSensitiveLog: (obj: ListUsersRequest) => any;
+}
+export interface ListUsersResponse {
+    
+    NextToken?: string;
+    
+    ServerId: string | undefined;
+    
+    Users: ListedUser[] | undefined;
+}
+export declare namespace ListUsersResponse {
+    
+    const filterSensitiveLog: (obj: ListUsersResponse) => any;
+}
+export interface ListWorkflowsRequest {
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListWorkflowsRequest {
+    
+    const filterSensitiveLog: (obj: ListWorkflowsRequest) => any;
+}
+export interface ListWorkflowsResponse {
+    
+    NextToken?: string;
+    
+    Workflows: ListedWorkflow[] | undefined;
+}
+export declare namespace ListWorkflowsResponse {
+    
+    const filterSensitiveLog: (obj: ListWorkflowsResponse) => any;
+}
+export interface SendWorkflowStepStateRequest {
+    
+    WorkflowId: string | undefined;
+    
+    ExecutionId: string | undefined;
+    
+    Token: string | undefined;
+    
+    Status: CustomStepStatus | string | undefined;
+}
+export declare namespace SendWorkflowStepStateRequest {
+    
+    const filterSensitiveLog: (obj: SendWorkflowStepStateRequest) => any;
+}
+export interface SendWorkflowStepStateResponse {
+}
+export declare namespace SendWorkflowStepStateResponse {
+    
+    const filterSensitiveLog: (obj: SendWorkflowStepStateResponse) => any;
+}
+export interface StartServerRequest {
+    
+    ServerId: string | undefined;
+}
+export declare namespace StartServerRequest {
+    
+    const filterSensitiveLog: (obj: StartServerRequest) => any;
+}
+export interface StopServerRequest {
+    
+    ServerId: string | undefined;
+}
+export declare namespace StopServerRequest {
+    
+    const filterSensitiveLog: (obj: StopServerRequest) => any;
+}
+export interface TagResourceRequest {
+    
+    Arn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TestIdentityProviderRequest {
+    
+    ServerId: string | undefined;
+    
+    ServerProtocol?: Protocol | string;
+    
+    SourceIp?: string;
+    
+    UserName: string | undefined;
+    
+    UserPassword?: string;
+}
+export declare namespace TestIdentityProviderRequest {
+    
+    const filterSensitiveLog: (obj: TestIdentityProviderRequest) => any;
+}
+export interface TestIdentityProviderResponse {
+    
+    Response?: string;
+    
+    StatusCode: number | undefined;
+    
+    Message?: string;
+    
+    Url: string | undefined;
+}
+export declare namespace TestIdentityProviderResponse {
+    
+    const filterSensitiveLog: (obj: TestIdentityProviderResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    Arn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UpdateAccessRequest {
+    
+    HomeDirectory?: string;
+    
+    HomeDirectoryType?: HomeDirectoryType | string;
+    
+    HomeDirectoryMappings?: HomeDirectoryMapEntry[];
+    
+    Policy?: string;
+    
+    PosixProfile?: PosixProfile;
+    
+    Role?: string;
+    
+    ServerId: string | undefined;
+    
+    ExternalId: string | undefined;
+}
+export declare namespace UpdateAccessRequest {
+    
+    const filterSensitiveLog: (obj: UpdateAccessRequest) => any;
+}
+export interface UpdateAccessResponse {
+    
+    ServerId: string | undefined;
+    
+    ExternalId: string | undefined;
+}
+export declare namespace UpdateAccessResponse {
+    
+    const filterSensitiveLog: (obj: UpdateAccessResponse) => any;
+}
+export interface UpdateServerRequest {
+    
+    Certificate?: string;
+    
+    ProtocolDetails?: ProtocolDetails;
+    
+    EndpointDetails?: EndpointDetails;
+    
+    EndpointType?: EndpointType | string;
+    
+    HostKey?: string;
+    
+    IdentityProviderDetails?: IdentityProviderDetails;
+    
+    LoggingRole?: string;
+    
+    Protocols?: (Protocol | string)[];
+    
+    SecurityPolicyName?: string;
+    
+    ServerId: string | undefined;
+    
+    WorkflowDetails?: WorkflowDetails;
+}
+export declare namespace UpdateServerRequest {
+    
+    const filterSensitiveLog: (obj: UpdateServerRequest) => any;
+}
+export interface UpdateServerResponse {
+    
+    ServerId: string | undefined;
+}
+export declare namespace UpdateServerResponse {
+    
+    const filterSensitiveLog: (obj: UpdateServerResponse) => any;
+}
+export interface UpdateUserRequest {
+    
+    HomeDirectory?: string;
+    
+    HomeDirectoryType?: HomeDirectoryType | string;
+    
+    HomeDirectoryMappings?: HomeDirectoryMapEntry[];
+    
+    Policy?: string;
+    
+    PosixProfile?: PosixProfile;
+    
+    Role?: string;
+    
+    ServerId: string | undefined;
+    
+    UserName: string | undefined;
+}
+export declare namespace UpdateUserRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUserRequest) => any;
+}
+
+export interface UpdateUserResponse {
+    
+    ServerId: string | undefined;
+    
+    UserName: string | undefined;
+}
+export declare namespace UpdateUserResponse {
+    
+    const filterSensitiveLog: (obj: UpdateUserResponse) => any;
+}