@aws-sdk/client-workdocs 3.50.0 → 3.53.0

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

@@ -0,0 +1,1622 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { WorkDocsServiceException as __BaseException } from "./WorkDocsServiceException";
+export interface AbortDocumentVersionUploadRequest {
+    
+    AuthenticationToken?: string;
+    
+    DocumentId: string | undefined;
+    
+    VersionId: string | undefined;
+}
+export declare namespace AbortDocumentVersionUploadRequest {
+    
+    const filterSensitiveLog: (obj: AbortDocumentVersionUploadRequest) => any;
+}
+
+export declare class EntityNotExistsException extends __BaseException {
+    readonly name: "EntityNotExistsException";
+    readonly $fault: "client";
+    Message?: string;
+    EntityIds?: string[];
+    
+    constructor(opts: __ExceptionOptionType<EntityNotExistsException, __BaseException>);
+}
+
+export declare class FailedDependencyException extends __BaseException {
+    readonly name: "FailedDependencyException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<FailedDependencyException, __BaseException>);
+}
+
+export declare class ProhibitedStateException extends __BaseException {
+    readonly name: "ProhibitedStateException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ProhibitedStateException, __BaseException>);
+}
+
+export declare class ServiceUnavailableException extends __BaseException {
+    readonly name: "ServiceUnavailableException";
+    readonly $fault: "server";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>);
+}
+
+export declare class UnauthorizedOperationException extends __BaseException {
+    readonly name: "UnauthorizedOperationException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnauthorizedOperationException, __BaseException>);
+}
+
+export declare class UnauthorizedResourceAccessException extends __BaseException {
+    readonly name: "UnauthorizedResourceAccessException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnauthorizedResourceAccessException, __BaseException>);
+}
+export interface ActivateUserRequest {
+    
+    UserId: string | undefined;
+    
+    AuthenticationToken?: string;
+}
+export declare namespace ActivateUserRequest {
+    
+    const filterSensitiveLog: (obj: ActivateUserRequest) => any;
+}
+export declare enum LocaleType {
+    DE = "de",
+    DEFAULT = "default",
+    EN = "en",
+    ES = "es",
+    FR = "fr",
+    JA = "ja",
+    KO = "ko",
+    PT_BR = "pt_BR",
+    RU = "ru",
+    ZH_CN = "zh_CN",
+    ZH_TW = "zh_TW"
+}
+export declare enum UserStatusType {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    PENDING = "PENDING"
+}
+export declare enum StorageType {
+    QUOTA = "QUOTA",
+    UNLIMITED = "UNLIMITED"
+}
+
+export interface StorageRuleType {
+    
+    StorageAllocatedInBytes?: number;
+    
+    StorageType?: StorageType | string;
+}
+export declare namespace StorageRuleType {
+    
+    const filterSensitiveLog: (obj: StorageRuleType) => any;
+}
+
+export interface UserStorageMetadata {
+    
+    StorageUtilizedInBytes?: number;
+    
+    StorageRule?: StorageRuleType;
+}
+export declare namespace UserStorageMetadata {
+    
+    const filterSensitiveLog: (obj: UserStorageMetadata) => any;
+}
+export declare enum UserType {
+    ADMIN = "ADMIN",
+    MINIMALUSER = "MINIMALUSER",
+    POWERUSER = "POWERUSER",
+    USER = "USER",
+    WORKSPACESUSER = "WORKSPACESUSER"
+}
+
+export interface User {
+    
+    Id?: string;
+    
+    Username?: string;
+    
+    EmailAddress?: string;
+    
+    GivenName?: string;
+    
+    Surname?: string;
+    
+    OrganizationId?: string;
+    
+    RootFolderId?: string;
+    
+    RecycleBinFolderId?: string;
+    
+    Status?: UserStatusType | string;
+    
+    Type?: UserType | string;
+    
+    CreatedTimestamp?: Date;
+    
+    ModifiedTimestamp?: Date;
+    
+    TimeZoneId?: string;
+    
+    Locale?: LocaleType | string;
+    
+    Storage?: UserStorageMetadata;
+}
+export declare namespace User {
+    
+    const filterSensitiveLog: (obj: User) => any;
+}
+export interface ActivateUserResponse {
+    
+    User?: User;
+}
+export declare namespace ActivateUserResponse {
+    
+    const filterSensitiveLog: (obj: ActivateUserResponse) => any;
+}
+export declare enum CommentStatusType {
+    DELETED = "DELETED",
+    DRAFT = "DRAFT",
+    PUBLISHED = "PUBLISHED"
+}
+
+export interface CommentMetadata {
+    
+    CommentId?: string;
+    
+    Contributor?: User;
+    
+    CreatedTimestamp?: Date;
+    
+    CommentStatus?: CommentStatusType | string;
+    
+    RecipientId?: string;
+}
+export declare namespace CommentMetadata {
+    
+    const filterSensitiveLog: (obj: CommentMetadata) => any;
+}
+
+export interface UserMetadata {
+    
+    Id?: string;
+    
+    Username?: string;
+    
+    GivenName?: string;
+    
+    Surname?: string;
+    
+    EmailAddress?: string;
+}
+export declare namespace UserMetadata {
+    
+    const filterSensitiveLog: (obj: UserMetadata) => any;
+}
+export declare enum ResourceType {
+    DOCUMENT = "DOCUMENT",
+    FOLDER = "FOLDER"
+}
+
+export interface ResourceMetadata {
+    
+    Type?: ResourceType | string;
+    
+    Name?: string;
+    
+    OriginalName?: string;
+    
+    Id?: string;
+    
+    VersionId?: string;
+    
+    Owner?: UserMetadata;
+    
+    ParentId?: string;
+}
+export declare namespace ResourceMetadata {
+    
+    const filterSensitiveLog: (obj: ResourceMetadata) => any;
+}
+
+export interface GroupMetadata {
+    
+    Id?: string;
+    
+    Name?: string;
+}
+export declare namespace GroupMetadata {
+    
+    const filterSensitiveLog: (obj: GroupMetadata) => any;
+}
+
+export interface Participants {
+    
+    Users?: UserMetadata[];
+    
+    Groups?: GroupMetadata[];
+}
+export declare namespace Participants {
+    
+    const filterSensitiveLog: (obj: Participants) => any;
+}
+export declare enum ActivityType {
+    DOCUMENT_ANNOTATION_ADDED = "DOCUMENT_ANNOTATION_ADDED",
+    DOCUMENT_ANNOTATION_DELETED = "DOCUMENT_ANNOTATION_DELETED",
+    DOCUMENT_CHECKED_IN = "DOCUMENT_CHECKED_IN",
+    DOCUMENT_CHECKED_OUT = "DOCUMENT_CHECKED_OUT",
+    DOCUMENT_COMMENT_ADDED = "DOCUMENT_COMMENT_ADDED",
+    DOCUMENT_COMMENT_DELETED = "DOCUMENT_COMMENT_DELETED",
+    DOCUMENT_MOVED = "DOCUMENT_MOVED",
+    DOCUMENT_RECYCLED = "DOCUMENT_RECYCLED",
+    DOCUMENT_RENAMED = "DOCUMENT_RENAMED",
+    DOCUMENT_RESTORED = "DOCUMENT_RESTORED",
+    DOCUMENT_REVERTED = "DOCUMENT_REVERTED",
+    DOCUMENT_SHAREABLE_LINK_CREATED = "DOCUMENT_SHAREABLE_LINK_CREATED",
+    DOCUMENT_SHAREABLE_LINK_PERMISSION_CHANGED = "DOCUMENT_SHAREABLE_LINK_PERMISSION_CHANGED",
+    DOCUMENT_SHAREABLE_LINK_REMOVED = "DOCUMENT_SHAREABLE_LINK_REMOVED",
+    DOCUMENT_SHARED = "DOCUMENT_SHARED",
+    DOCUMENT_SHARE_PERMISSION_CHANGED = "DOCUMENT_SHARE_PERMISSION_CHANGED",
+    DOCUMENT_UNSHARED = "DOCUMENT_UNSHARED",
+    DOCUMENT_VERSION_DELETED = "DOCUMENT_VERSION_DELETED",
+    DOCUMENT_VERSION_DOWNLOADED = "DOCUMENT_VERSION_DOWNLOADED",
+    DOCUMENT_VERSION_UPLOADED = "DOCUMENT_VERSION_UPLOADED",
+    DOCUMENT_VERSION_VIEWED = "DOCUMENT_VERSION_VIEWED",
+    FOLDER_CREATED = "FOLDER_CREATED",
+    FOLDER_DELETED = "FOLDER_DELETED",
+    FOLDER_MOVED = "FOLDER_MOVED",
+    FOLDER_RECYCLED = "FOLDER_RECYCLED",
+    FOLDER_RENAMED = "FOLDER_RENAMED",
+    FOLDER_RESTORED = "FOLDER_RESTORED",
+    FOLDER_SHAREABLE_LINK_CREATED = "FOLDER_SHAREABLE_LINK_CREATED",
+    FOLDER_SHAREABLE_LINK_PERMISSION_CHANGED = "FOLDER_SHAREABLE_LINK_PERMISSION_CHANGED",
+    FOLDER_SHAREABLE_LINK_REMOVED = "FOLDER_SHAREABLE_LINK_REMOVED",
+    FOLDER_SHARED = "FOLDER_SHARED",
+    FOLDER_SHARE_PERMISSION_CHANGED = "FOLDER_SHARE_PERMISSION_CHANGED",
+    FOLDER_UNSHARED = "FOLDER_UNSHARED"
+}
+
+export interface Activity {
+    
+    Type?: ActivityType | string;
+    
+    TimeStamp?: Date;
+    
+    IsIndirectActivity?: boolean;
+    
+    OrganizationId?: string;
+    
+    Initiator?: UserMetadata;
+    
+    Participants?: Participants;
+    
+    ResourceMetadata?: ResourceMetadata;
+    
+    OriginalParent?: ResourceMetadata;
+    
+    CommentMetadata?: CommentMetadata;
+}
+export declare namespace Activity {
+    
+    const filterSensitiveLog: (obj: Activity) => any;
+}
+
+export interface NotificationOptions {
+    
+    SendEmail?: boolean;
+    
+    EmailMessage?: string;
+}
+export declare namespace NotificationOptions {
+    
+    const filterSensitiveLog: (obj: NotificationOptions) => any;
+}
+export declare enum RoleType {
+    CONTRIBUTOR = "CONTRIBUTOR",
+    COOWNER = "COOWNER",
+    OWNER = "OWNER",
+    VIEWER = "VIEWER"
+}
+export declare enum PrincipalType {
+    ANONYMOUS = "ANONYMOUS",
+    GROUP = "GROUP",
+    INVITE = "INVITE",
+    ORGANIZATION = "ORGANIZATION",
+    USER = "USER"
+}
+
+export interface SharePrincipal {
+    
+    Id: string | undefined;
+    
+    Type: PrincipalType | string | undefined;
+    
+    Role: RoleType | string | undefined;
+}
+export declare namespace SharePrincipal {
+    
+    const filterSensitiveLog: (obj: SharePrincipal) => any;
+}
+export interface AddResourcePermissionsRequest {
+    
+    AuthenticationToken?: string;
+    
+    ResourceId: string | undefined;
+    
+    Principals: SharePrincipal[] | undefined;
+    
+    NotificationOptions?: NotificationOptions;
+}
+export declare namespace AddResourcePermissionsRequest {
+    
+    const filterSensitiveLog: (obj: AddResourcePermissionsRequest) => any;
+}
+export declare enum ShareStatusType {
+    FAILURE = "FAILURE",
+    SUCCESS = "SUCCESS"
+}
+
+export interface ShareResult {
+    
+    PrincipalId?: string;
+    
+    InviteePrincipalId?: string;
+    
+    Role?: RoleType | string;
+    
+    Status?: ShareStatusType | string;
+    
+    ShareId?: string;
+    
+    StatusMessage?: string;
+}
+export declare namespace ShareResult {
+    
+    const filterSensitiveLog: (obj: ShareResult) => any;
+}
+export interface AddResourcePermissionsResponse {
+    
+    ShareResults?: ShareResult[];
+}
+export declare namespace AddResourcePermissionsResponse {
+    
+    const filterSensitiveLog: (obj: AddResourcePermissionsResponse) => any;
+}
+export declare enum CommentVisibilityType {
+    PRIVATE = "PRIVATE",
+    PUBLIC = "PUBLIC"
+}
+export interface CreateCommentRequest {
+    
+    AuthenticationToken?: string;
+    
+    DocumentId: string | undefined;
+    
+    VersionId: string | undefined;
+    
+    ParentId?: string;
+    
+    ThreadId?: string;
+    
+    Text: string | undefined;
+    
+    Visibility?: CommentVisibilityType | string;
+    
+    NotifyCollaborators?: boolean;
+}
+export declare namespace CreateCommentRequest {
+    
+    const filterSensitiveLog: (obj: CreateCommentRequest) => any;
+}
+
+export interface Comment {
+    
+    CommentId: string | undefined;
+    
+    ParentId?: string;
+    
+    ThreadId?: string;
+    
+    Text?: string;
+    
+    Contributor?: User;
+    
+    CreatedTimestamp?: Date;
+    
+    Status?: CommentStatusType | string;
+    
+    Visibility?: CommentVisibilityType | string;
+    
+    RecipientId?: string;
+}
+export declare namespace Comment {
+    
+    const filterSensitiveLog: (obj: Comment) => any;
+}
+export interface CreateCommentResponse {
+    
+    Comment?: Comment;
+}
+export declare namespace CreateCommentResponse {
+    
+    const filterSensitiveLog: (obj: CreateCommentResponse) => any;
+}
+
+export declare class DocumentLockedForCommentsException extends __BaseException {
+    readonly name: "DocumentLockedForCommentsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DocumentLockedForCommentsException, __BaseException>);
+}
+
+export declare class InvalidCommentOperationException extends __BaseException {
+    readonly name: "InvalidCommentOperationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidCommentOperationException, __BaseException>);
+}
+export interface CreateCustomMetadataRequest {
+    
+    AuthenticationToken?: string;
+    
+    ResourceId: string | undefined;
+    
+    VersionId?: string;
+    
+    CustomMetadata: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace CreateCustomMetadataRequest {
+    
+    const filterSensitiveLog: (obj: CreateCustomMetadataRequest) => any;
+}
+export interface CreateCustomMetadataResponse {
+}
+export declare namespace CreateCustomMetadataResponse {
+    
+    const filterSensitiveLog: (obj: CreateCustomMetadataResponse) => any;
+}
+
+export declare class CustomMetadataLimitExceededException extends __BaseException {
+    readonly name: "CustomMetadataLimitExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<CustomMetadataLimitExceededException, __BaseException>);
+}
+
+export declare class ConflictingOperationException extends __BaseException {
+    readonly name: "ConflictingOperationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConflictingOperationException, __BaseException>);
+}
+export interface CreateFolderRequest {
+    
+    AuthenticationToken?: string;
+    
+    Name?: string;
+    
+    ParentFolderId: string | undefined;
+}
+export declare namespace CreateFolderRequest {
+    
+    const filterSensitiveLog: (obj: CreateFolderRequest) => any;
+}
+export declare enum ResourceStateType {
+    ACTIVE = "ACTIVE",
+    RECYCLED = "RECYCLED",
+    RECYCLING = "RECYCLING",
+    RESTORING = "RESTORING"
+}
+
+export interface FolderMetadata {
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    CreatorId?: string;
+    
+    ParentFolderId?: string;
+    
+    CreatedTimestamp?: Date;
+    
+    ModifiedTimestamp?: Date;
+    
+    ResourceState?: ResourceStateType | string;
+    
+    Signature?: string;
+    
+    Labels?: string[];
+    
+    Size?: number;
+    
+    LatestVersionSize?: number;
+}
+export declare namespace FolderMetadata {
+    
+    const filterSensitiveLog: (obj: FolderMetadata) => any;
+}
+export interface CreateFolderResponse {
+    
+    Metadata?: FolderMetadata;
+}
+export declare namespace CreateFolderResponse {
+    
+    const filterSensitiveLog: (obj: CreateFolderResponse) => any;
+}
+
+export declare class EntityAlreadyExistsException extends __BaseException {
+    readonly name: "EntityAlreadyExistsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<EntityAlreadyExistsException, __BaseException>);
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+export interface CreateLabelsRequest {
+    
+    ResourceId: string | undefined;
+    
+    Labels: string[] | undefined;
+    
+    AuthenticationToken?: string;
+}
+export declare namespace CreateLabelsRequest {
+    
+    const filterSensitiveLog: (obj: CreateLabelsRequest) => any;
+}
+export interface CreateLabelsResponse {
+}
+export declare namespace CreateLabelsResponse {
+    
+    const filterSensitiveLog: (obj: CreateLabelsResponse) => any;
+}
+
+export declare class TooManyLabelsException extends __BaseException {
+    readonly name: "TooManyLabelsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyLabelsException, __BaseException>);
+}
+export declare enum SubscriptionProtocolType {
+    HTTPS = "HTTPS"
+}
+export declare enum SubscriptionType {
+    ALL = "ALL"
+}
+export interface CreateNotificationSubscriptionRequest {
+    
+    OrganizationId: string | undefined;
+    
+    Endpoint: string | undefined;
+    
+    Protocol: SubscriptionProtocolType | string | undefined;
+    
+    SubscriptionType: SubscriptionType | string | undefined;
+}
+export declare namespace CreateNotificationSubscriptionRequest {
+    
+    const filterSensitiveLog: (obj: CreateNotificationSubscriptionRequest) => any;
+}
+
+export interface Subscription {
+    
+    SubscriptionId?: string;
+    
+    EndPoint?: string;
+    
+    Protocol?: SubscriptionProtocolType | string;
+}
+export declare namespace Subscription {
+    
+    const filterSensitiveLog: (obj: Subscription) => any;
+}
+export interface CreateNotificationSubscriptionResponse {
+    
+    Subscription?: Subscription;
+}
+export declare namespace CreateNotificationSubscriptionResponse {
+    
+    const filterSensitiveLog: (obj: CreateNotificationSubscriptionResponse) => any;
+}
+
+export declare class TooManySubscriptionsException extends __BaseException {
+    readonly name: "TooManySubscriptionsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManySubscriptionsException, __BaseException>);
+}
+export interface CreateUserRequest {
+    
+    OrganizationId?: string;
+    
+    Username: string | undefined;
+    
+    EmailAddress?: string;
+    
+    GivenName: string | undefined;
+    
+    Surname: string | undefined;
+    
+    Password: string | undefined;
+    
+    TimeZoneId?: string;
+    
+    StorageRule?: StorageRuleType;
+    
+    AuthenticationToken?: string;
+}
+export declare namespace CreateUserRequest {
+    
+    const filterSensitiveLog: (obj: CreateUserRequest) => any;
+}
+export interface CreateUserResponse {
+    
+    User?: User;
+}
+export declare namespace CreateUserResponse {
+    
+    const filterSensitiveLog: (obj: CreateUserResponse) => any;
+}
+export interface DeactivateUserRequest {
+    
+    UserId: string | undefined;
+    
+    AuthenticationToken?: string;
+}
+export declare namespace DeactivateUserRequest {
+    
+    const filterSensitiveLog: (obj: DeactivateUserRequest) => any;
+}
+export interface DeleteCommentRequest {
+    
+    AuthenticationToken?: string;
+    
+    DocumentId: string | undefined;
+    
+    VersionId: string | undefined;
+    
+    CommentId: string | undefined;
+}
+export declare namespace DeleteCommentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteCommentRequest) => any;
+}
+export interface DeleteCustomMetadataRequest {
+    
+    AuthenticationToken?: string;
+    
+    ResourceId: string | undefined;
+    
+    VersionId?: string;
+    
+    Keys?: string[];
+    
+    DeleteAll?: boolean;
+}
+export declare namespace DeleteCustomMetadataRequest {
+    
+    const filterSensitiveLog: (obj: DeleteCustomMetadataRequest) => any;
+}
+export interface DeleteCustomMetadataResponse {
+}
+export declare namespace DeleteCustomMetadataResponse {
+    
+    const filterSensitiveLog: (obj: DeleteCustomMetadataResponse) => any;
+}
+
+export declare class ConcurrentModificationException extends __BaseException {
+    readonly name: "ConcurrentModificationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ConcurrentModificationException, __BaseException>);
+}
+export interface DeleteDocumentRequest {
+    
+    AuthenticationToken?: string;
+    
+    DocumentId: string | undefined;
+}
+export declare namespace DeleteDocumentRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDocumentRequest) => any;
+}
+export interface DeleteFolderRequest {
+    
+    AuthenticationToken?: string;
+    
+    FolderId: string | undefined;
+}
+export declare namespace DeleteFolderRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFolderRequest) => any;
+}
+export interface DeleteFolderContentsRequest {
+    
+    AuthenticationToken?: string;
+    
+    FolderId: string | undefined;
+}
+export declare namespace DeleteFolderContentsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFolderContentsRequest) => any;
+}
+export interface DeleteLabelsRequest {
+    
+    ResourceId: string | undefined;
+    
+    AuthenticationToken?: string;
+    
+    Labels?: string[];
+    
+    DeleteAll?: boolean;
+}
+export declare namespace DeleteLabelsRequest {
+    
+    const filterSensitiveLog: (obj: DeleteLabelsRequest) => any;
+}
+export interface DeleteLabelsResponse {
+}
+export declare namespace DeleteLabelsResponse {
+    
+    const filterSensitiveLog: (obj: DeleteLabelsResponse) => any;
+}
+export interface DeleteNotificationSubscriptionRequest {
+    
+    SubscriptionId: string | undefined;
+    
+    OrganizationId: string | undefined;
+}
+export declare namespace DeleteNotificationSubscriptionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteNotificationSubscriptionRequest) => any;
+}
+export interface DeleteUserRequest {
+    
+    AuthenticationToken?: string;
+    
+    UserId: string | undefined;
+}
+export declare namespace DeleteUserRequest {
+    
+    const filterSensitiveLog: (obj: DeleteUserRequest) => any;
+}
+export interface DescribeActivitiesRequest {
+    
+    AuthenticationToken?: string;
+    
+    StartTime?: Date;
+    
+    EndTime?: Date;
+    
+    OrganizationId?: string;
+    
+    ActivityTypes?: string;
+    
+    ResourceId?: string;
+    
+    UserId?: string;
+    
+    IncludeIndirectActivities?: boolean;
+    
+    Limit?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeActivitiesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeActivitiesRequest) => any;
+}
+export interface DescribeActivitiesResponse {
+    
+    UserActivities?: Activity[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeActivitiesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeActivitiesResponse) => any;
+}
+
+export declare class InvalidArgumentException extends __BaseException {
+    readonly name: "InvalidArgumentException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidArgumentException, __BaseException>);
+}
+export interface DescribeCommentsRequest {
+    
+    AuthenticationToken?: string;
+    
+    DocumentId: string | undefined;
+    
+    VersionId: string | undefined;
+    
+    Limit?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeCommentsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCommentsRequest) => any;
+}
+export interface DescribeCommentsResponse {
+    
+    Comments?: Comment[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeCommentsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCommentsResponse) => any;
+}
+export interface DescribeDocumentVersionsRequest {
+    
+    AuthenticationToken?: string;
+    
+    DocumentId: string | undefined;
+    
+    Marker?: string;
+    
+    Limit?: number;
+    
+    Include?: string;
+    
+    Fields?: string;
+}
+export declare namespace DescribeDocumentVersionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDocumentVersionsRequest) => any;
+}
+export declare enum DocumentSourceType {
+    ORIGINAL = "ORIGINAL",
+    WITH_COMMENTS = "WITH_COMMENTS"
+}
+export declare enum DocumentStatusType {
+    ACTIVE = "ACTIVE",
+    INITIALIZED = "INITIALIZED"
+}
+export declare enum DocumentThumbnailType {
+    LARGE = "LARGE",
+    SMALL = "SMALL",
+    SMALL_HQ = "SMALL_HQ"
+}
+
+export interface DocumentVersionMetadata {
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    ContentType?: string;
+    
+    Size?: number;
+    
+    Signature?: string;
+    
+    Status?: DocumentStatusType | string;
+    
+    CreatedTimestamp?: Date;
+    
+    ModifiedTimestamp?: Date;
+    
+    ContentCreatedTimestamp?: Date;
+    
+    ContentModifiedTimestamp?: Date;
+    
+    CreatorId?: string;
+    
+    Thumbnail?: {
+        [key: string]: string;
+    };
+    
+    Source?: {
+        [key: string]: string;
+    };
+}
+export declare namespace DocumentVersionMetadata {
+    
+    const filterSensitiveLog: (obj: DocumentVersionMetadata) => any;
+}
+export interface DescribeDocumentVersionsResponse {
+    
+    DocumentVersions?: DocumentVersionMetadata[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeDocumentVersionsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDocumentVersionsResponse) => any;
+}
+export declare enum OrderType {
+    ASCENDING = "ASCENDING",
+    DESCENDING = "DESCENDING"
+}
+export declare enum ResourceSortType {
+    DATE = "DATE",
+    NAME = "NAME"
+}
+export declare enum FolderContentType {
+    ALL = "ALL",
+    DOCUMENT = "DOCUMENT",
+    FOLDER = "FOLDER"
+}
+export interface DescribeFolderContentsRequest {
+    
+    AuthenticationToken?: string;
+    
+    FolderId: string | undefined;
+    
+    Sort?: ResourceSortType | string;
+    
+    Order?: OrderType | string;
+    
+    Limit?: number;
+    
+    Marker?: string;
+    
+    Type?: FolderContentType | string;
+    
+    Include?: string;
+}
+export declare namespace DescribeFolderContentsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeFolderContentsRequest) => any;
+}
+
+export interface DocumentMetadata {
+    
+    Id?: string;
+    
+    CreatorId?: string;
+    
+    ParentFolderId?: string;
+    
+    CreatedTimestamp?: Date;
+    
+    ModifiedTimestamp?: Date;
+    
+    LatestVersionMetadata?: DocumentVersionMetadata;
+    
+    ResourceState?: ResourceStateType | string;
+    
+    Labels?: string[];
+}
+export declare namespace DocumentMetadata {
+    
+    const filterSensitiveLog: (obj: DocumentMetadata) => any;
+}
+export interface DescribeFolderContentsResponse {
+    
+    Folders?: FolderMetadata[];
+    
+    Documents?: DocumentMetadata[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeFolderContentsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeFolderContentsResponse) => any;
+}
+export interface DescribeGroupsRequest {
+    
+    AuthenticationToken?: string;
+    
+    SearchQuery: string | undefined;
+    
+    OrganizationId?: string;
+    
+    Marker?: string;
+    
+    Limit?: number;
+}
+export declare namespace DescribeGroupsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeGroupsRequest) => any;
+}
+export interface DescribeGroupsResponse {
+    
+    Groups?: GroupMetadata[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeGroupsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeGroupsResponse) => any;
+}
+export interface DescribeNotificationSubscriptionsRequest {
+    
+    OrganizationId: string | undefined;
+    
+    Marker?: string;
+    
+    Limit?: number;
+}
+export declare namespace DescribeNotificationSubscriptionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeNotificationSubscriptionsRequest) => any;
+}
+export interface DescribeNotificationSubscriptionsResponse {
+    
+    Subscriptions?: Subscription[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeNotificationSubscriptionsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeNotificationSubscriptionsResponse) => any;
+}
+export interface DescribeResourcePermissionsRequest {
+    
+    AuthenticationToken?: string;
+    
+    ResourceId: string | undefined;
+    
+    PrincipalId?: string;
+    
+    Limit?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeResourcePermissionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeResourcePermissionsRequest) => any;
+}
+export declare enum RolePermissionType {
+    DIRECT = "DIRECT",
+    INHERITED = "INHERITED"
+}
+
+export interface PermissionInfo {
+    
+    Role?: RoleType | string;
+    
+    Type?: RolePermissionType | string;
+}
+export declare namespace PermissionInfo {
+    
+    const filterSensitiveLog: (obj: PermissionInfo) => any;
+}
+
+export interface Principal {
+    
+    Id?: string;
+    
+    Type?: PrincipalType | string;
+    
+    Roles?: PermissionInfo[];
+}
+export declare namespace Principal {
+    
+    const filterSensitiveLog: (obj: Principal) => any;
+}
+export interface DescribeResourcePermissionsResponse {
+    
+    Principals?: Principal[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeResourcePermissionsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeResourcePermissionsResponse) => any;
+}
+export interface DescribeRootFoldersRequest {
+    
+    AuthenticationToken: string | undefined;
+    
+    Limit?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeRootFoldersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeRootFoldersRequest) => any;
+}
+export interface DescribeRootFoldersResponse {
+    
+    Folders?: FolderMetadata[];
+    
+    Marker?: string;
+}
+export declare namespace DescribeRootFoldersResponse {
+    
+    const filterSensitiveLog: (obj: DescribeRootFoldersResponse) => any;
+}
+export declare enum UserFilterType {
+    ACTIVE_PENDING = "ACTIVE_PENDING",
+    ALL = "ALL"
+}
+export declare enum UserSortType {
+    FULL_NAME = "FULL_NAME",
+    STORAGE_LIMIT = "STORAGE_LIMIT",
+    STORAGE_USED = "STORAGE_USED",
+    USER_NAME = "USER_NAME",
+    USER_STATUS = "USER_STATUS"
+}
+export interface DescribeUsersRequest {
+    
+    AuthenticationToken?: string;
+    
+    OrganizationId?: string;
+    
+    UserIds?: string;
+    
+    Query?: string;
+    
+    Include?: UserFilterType | string;
+    
+    Order?: OrderType | string;
+    
+    Sort?: UserSortType | string;
+    
+    Marker?: string;
+    
+    Limit?: number;
+    
+    Fields?: string;
+}
+export declare namespace DescribeUsersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeUsersRequest) => any;
+}
+export interface DescribeUsersResponse {
+    
+    Users?: User[];
+    
+    TotalNumberOfUsers?: number;
+    
+    Marker?: string;
+}
+export declare namespace DescribeUsersResponse {
+    
+    const filterSensitiveLog: (obj: DescribeUsersResponse) => any;
+}
+
+export declare class RequestedEntityTooLargeException extends __BaseException {
+    readonly name: "RequestedEntityTooLargeException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<RequestedEntityTooLargeException, __BaseException>);
+}
+export interface GetCurrentUserRequest {
+    
+    AuthenticationToken: string | undefined;
+}
+export declare namespace GetCurrentUserRequest {
+    
+    const filterSensitiveLog: (obj: GetCurrentUserRequest) => any;
+}
+export interface GetCurrentUserResponse {
+    
+    User?: User;
+}
+export declare namespace GetCurrentUserResponse {
+    
+    const filterSensitiveLog: (obj: GetCurrentUserResponse) => any;
+}
+export interface GetDocumentRequest {
+    
+    AuthenticationToken?: string;
+    
+    DocumentId: string | undefined;
+    
+    IncludeCustomMetadata?: boolean;
+}
+export declare namespace GetDocumentRequest {
+    
+    const filterSensitiveLog: (obj: GetDocumentRequest) => any;
+}
+export interface GetDocumentResponse {
+    
+    Metadata?: DocumentMetadata;
+    
+    CustomMetadata?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetDocumentResponse {
+    
+    const filterSensitiveLog: (obj: GetDocumentResponse) => any;
+}
+
+export declare class InvalidPasswordException extends __BaseException {
+    readonly name: "InvalidPasswordException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidPasswordException, __BaseException>);
+}
+export interface GetDocumentPathRequest {
+    
+    AuthenticationToken?: string;
+    
+    DocumentId: string | undefined;
+    
+    Limit?: number;
+    
+    Fields?: string;
+    
+    Marker?: string;
+}
+export declare namespace GetDocumentPathRequest {
+    
+    const filterSensitiveLog: (obj: GetDocumentPathRequest) => any;
+}
+
+export interface ResourcePathComponent {
+    
+    Id?: string;
+    
+    Name?: string;
+}
+export declare namespace ResourcePathComponent {
+    
+    const filterSensitiveLog: (obj: ResourcePathComponent) => any;
+}
+
+export interface ResourcePath {
+    
+    Components?: ResourcePathComponent[];
+}
+export declare namespace ResourcePath {
+    
+    const filterSensitiveLog: (obj: ResourcePath) => any;
+}
+export interface GetDocumentPathResponse {
+    
+    Path?: ResourcePath;
+}
+export declare namespace GetDocumentPathResponse {
+    
+    const filterSensitiveLog: (obj: GetDocumentPathResponse) => any;
+}
+export interface GetDocumentVersionRequest {
+    
+    AuthenticationToken?: string;
+    
+    DocumentId: string | undefined;
+    
+    VersionId: string | undefined;
+    
+    Fields?: string;
+    
+    IncludeCustomMetadata?: boolean;
+}
+export declare namespace GetDocumentVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetDocumentVersionRequest) => any;
+}
+export interface GetDocumentVersionResponse {
+    
+    Metadata?: DocumentVersionMetadata;
+    
+    CustomMetadata?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetDocumentVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetDocumentVersionResponse) => any;
+}
+export interface GetFolderRequest {
+    
+    AuthenticationToken?: string;
+    
+    FolderId: string | undefined;
+    
+    IncludeCustomMetadata?: boolean;
+}
+export declare namespace GetFolderRequest {
+    
+    const filterSensitiveLog: (obj: GetFolderRequest) => any;
+}
+export interface GetFolderResponse {
+    
+    Metadata?: FolderMetadata;
+    
+    CustomMetadata?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetFolderResponse {
+    
+    const filterSensitiveLog: (obj: GetFolderResponse) => any;
+}
+export interface GetFolderPathRequest {
+    
+    AuthenticationToken?: string;
+    
+    FolderId: string | undefined;
+    
+    Limit?: number;
+    
+    Fields?: string;
+    
+    Marker?: string;
+}
+export declare namespace GetFolderPathRequest {
+    
+    const filterSensitiveLog: (obj: GetFolderPathRequest) => any;
+}
+export interface GetFolderPathResponse {
+    
+    Path?: ResourcePath;
+}
+export declare namespace GetFolderPathResponse {
+    
+    const filterSensitiveLog: (obj: GetFolderPathResponse) => any;
+}
+export declare enum ResourceCollectionType {
+    SHARED_WITH_ME = "SHARED_WITH_ME"
+}
+export interface GetResourcesRequest {
+    
+    AuthenticationToken?: string;
+    
+    UserId?: string;
+    
+    CollectionType?: ResourceCollectionType | string;
+    
+    Limit?: number;
+    
+    Marker?: string;
+}
+export declare namespace GetResourcesRequest {
+    
+    const filterSensitiveLog: (obj: GetResourcesRequest) => any;
+}
+export interface GetResourcesResponse {
+    
+    Folders?: FolderMetadata[];
+    
+    Documents?: DocumentMetadata[];
+    
+    Marker?: string;
+}
+export declare namespace GetResourcesResponse {
+    
+    const filterSensitiveLog: (obj: GetResourcesResponse) => any;
+}
+
+export declare class DraftUploadOutOfSyncException extends __BaseException {
+    readonly name: "DraftUploadOutOfSyncException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DraftUploadOutOfSyncException, __BaseException>);
+}
+export interface InitiateDocumentVersionUploadRequest {
+    
+    AuthenticationToken?: string;
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    ContentCreatedTimestamp?: Date;
+    
+    ContentModifiedTimestamp?: Date;
+    
+    ContentType?: string;
+    
+    DocumentSizeInBytes?: number;
+    
+    ParentFolderId: string | undefined;
+}
+export declare namespace InitiateDocumentVersionUploadRequest {
+    
+    const filterSensitiveLog: (obj: InitiateDocumentVersionUploadRequest) => any;
+}
+
+export interface UploadMetadata {
+    
+    UploadUrl?: string;
+    
+    SignedHeaders?: {
+        [key: string]: string;
+    };
+}
+export declare namespace UploadMetadata {
+    
+    const filterSensitiveLog: (obj: UploadMetadata) => any;
+}
+export interface InitiateDocumentVersionUploadResponse {
+    
+    Metadata?: DocumentMetadata;
+    
+    UploadMetadata?: UploadMetadata;
+}
+export declare namespace InitiateDocumentVersionUploadResponse {
+    
+    const filterSensitiveLog: (obj: InitiateDocumentVersionUploadResponse) => any;
+}
+
+export declare class ResourceAlreadyCheckedOutException extends __BaseException {
+    readonly name: "ResourceAlreadyCheckedOutException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceAlreadyCheckedOutException, __BaseException>);
+}
+
+export declare class StorageLimitExceededException extends __BaseException {
+    readonly name: "StorageLimitExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<StorageLimitExceededException, __BaseException>);
+}
+
+export declare class StorageLimitWillExceedException extends __BaseException {
+    readonly name: "StorageLimitWillExceedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<StorageLimitWillExceedException, __BaseException>);
+}
+export interface RemoveAllResourcePermissionsRequest {
+    
+    AuthenticationToken?: string;
+    
+    ResourceId: string | undefined;
+}
+export declare namespace RemoveAllResourcePermissionsRequest {
+    
+    const filterSensitiveLog: (obj: RemoveAllResourcePermissionsRequest) => any;
+}
+export interface RemoveResourcePermissionRequest {
+    
+    AuthenticationToken?: string;
+    
+    ResourceId: string | undefined;
+    
+    PrincipalId: string | undefined;
+    
+    PrincipalType?: PrincipalType | string;
+}
+export declare namespace RemoveResourcePermissionRequest {
+    
+    const filterSensitiveLog: (obj: RemoveResourcePermissionRequest) => any;
+}
+export interface UpdateDocumentRequest {
+    
+    AuthenticationToken?: string;
+    
+    DocumentId: string | undefined;
+    
+    Name?: string;
+    
+    ParentFolderId?: string;
+    
+    ResourceState?: ResourceStateType | string;
+}
+export declare namespace UpdateDocumentRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDocumentRequest) => any;
+}
+
+export declare class InvalidOperationException extends __BaseException {
+    readonly name: "InvalidOperationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidOperationException, __BaseException>);
+}
+export declare enum DocumentVersionStatus {
+    ACTIVE = "ACTIVE"
+}
+export interface UpdateDocumentVersionRequest {
+    
+    AuthenticationToken?: string;
+    
+    DocumentId: string | undefined;
+    
+    VersionId: string | undefined;
+    
+    VersionStatus?: DocumentVersionStatus | string;
+}
+export declare namespace UpdateDocumentVersionRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDocumentVersionRequest) => any;
+}
+export interface UpdateFolderRequest {
+    
+    AuthenticationToken?: string;
+    
+    FolderId: string | undefined;
+    
+    Name?: string;
+    
+    ParentFolderId?: string;
+    
+    ResourceState?: ResourceStateType | string;
+}
+export declare namespace UpdateFolderRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFolderRequest) => any;
+}
+
+export declare class DeactivatingLastSystemUserException extends __BaseException {
+    readonly name: "DeactivatingLastSystemUserException";
+    readonly $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    constructor(opts: __ExceptionOptionType<DeactivatingLastSystemUserException, __BaseException>);
+}
+
+export declare class IllegalUserStateException extends __BaseException {
+    readonly name: "IllegalUserStateException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IllegalUserStateException, __BaseException>);
+}
+export declare enum BooleanEnumType {
+    FALSE = "FALSE",
+    TRUE = "TRUE"
+}
+export interface UpdateUserRequest {
+    
+    AuthenticationToken?: string;
+    
+    UserId: string | undefined;
+    
+    GivenName?: string;
+    
+    Surname?: string;
+    
+    Type?: UserType | string;
+    
+    StorageRule?: StorageRuleType;
+    
+    TimeZoneId?: string;
+    
+    Locale?: LocaleType | string;
+    
+    GrantPoweruserPrivileges?: BooleanEnumType | string;
+}
+export declare namespace UpdateUserRequest {
+    
+    const filterSensitiveLog: (obj: UpdateUserRequest) => any;
+}
+export interface UpdateUserResponse {
+    
+    User?: User;
+}
+export declare namespace UpdateUserResponse {
+    
+    const filterSensitiveLog: (obj: UpdateUserResponse) => any;
+}