import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type AuthenticationHeaderType = string | redacted.Redacted<string>;
export type ResourceIdType = string;
export type DocumentVersionIdType = string;
export type ErrorMessageType = string;
export type IdType = string;
export type ExceptionCodeType = string;
export type UsernameType = string | redacted.Redacted<string>;
export type EmailAddressType = string | redacted.Redacted<string>;
export type UserAttributeValueType = string | redacted.Redacted<string>;
export type TimeZoneIdType = string;
export type SizeType = number;
export type PositiveSizeType = number;
export type MessageType = string | redacted.Redacted<string>;
export type CommentIdType = string;
export type CommentTextType = string | redacted.Redacted<string>;
export type CustomMetadataKeyType = string;
export type CustomMetadataValueType = string;
export type ResourceNameType = string | redacted.Redacted<string>;
export type HashType = string;
export type SharedLabel = string;
export type SubscriptionEndPointType = string;
export type PasswordType = string | redacted.Redacted<string>;
export type ActivityNamesFilterType = string;
export type LimitType = number;
export type SearchMarkerType = string;
export type GroupNameType = string;
export type MarkerType = string;
export type PageMarkerType = string;
export type FieldNamesType = string;
export type DocumentContentType = string;
export type UrlType = string | redacted.Redacted<string>;
export type SearchQueryType = string | redacted.Redacted<string>;
export type PositiveIntegerType = number;
export type UserIdsType = string;
export type HeaderNameType = string;
export type HeaderValueType = string;
export type SearchLabel = string;
export type SearchAncestorId = string;
export type LongType = number;
export type SearchResultsLimitType = number;
export type NextMarkerType = string;
export type ResponseItemWebUrl = string | redacted.Redacted<string>;
export interface AbortDocumentVersionUploadRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
    VersionId: string;
}
export declare const AbortDocumentVersionUploadRequest: S.Schema<AbortDocumentVersionUploadRequest>;
export interface AbortDocumentVersionUploadResponse {
}
export declare const AbortDocumentVersionUploadResponse: S.Schema<AbortDocumentVersionUploadResponse>;
export type EntityIdList = string[];
export declare const EntityIdList: S.$Array<S.String>;
export interface ActivateUserRequest {
    UserId: string;
    AuthenticationToken?: string | redacted.Redacted<string>;
}
export declare const ActivateUserRequest: S.Schema<ActivateUserRequest>;
export type UserStatusType = "ACTIVE" | "INACTIVE" | "PENDING" | (string & {});
export declare const UserStatusType: S.String;
export type UserType = "USER" | "ADMIN" | "POWERUSER" | "MINIMALUSER" | "WORKSPACESUSER" | (string & {});
export declare const UserType: S.String;
export type LocaleType = "en" | "fr" | "ko" | "de" | "es" | "ja" | "ru" | "zh_CN" | "zh_TW" | "pt_BR" | "default" | (string & {});
export declare const LocaleType: S.String;
export type StorageType = "UNLIMITED" | "QUOTA" | (string & {});
export declare const StorageType: S.String;
export interface StorageRuleType {
    StorageAllocatedInBytes?: number;
    StorageType?: StorageType;
}
export declare const StorageRuleType: S.Schema<StorageRuleType>;
export interface UserStorageMetadata {
    StorageUtilizedInBytes?: number;
    StorageRule?: StorageRuleType;
}
export declare const UserStorageMetadata: S.Schema<UserStorageMetadata>;
export interface User {
    Id?: string;
    Username?: string | redacted.Redacted<string>;
    EmailAddress?: string | redacted.Redacted<string>;
    GivenName?: string | redacted.Redacted<string>;
    Surname?: string | redacted.Redacted<string>;
    OrganizationId?: string;
    RootFolderId?: string;
    RecycleBinFolderId?: string;
    Status?: UserStatusType;
    Type?: UserType;
    CreatedTimestamp?: Date;
    ModifiedTimestamp?: Date;
    TimeZoneId?: string;
    Locale?: LocaleType;
    Storage?: UserStorageMetadata;
}
export declare const User: S.Schema<User>;
export interface ActivateUserResponse {
    User?: User;
}
export declare const ActivateUserResponse: S.Schema<ActivateUserResponse>;
export type PrincipalType = "USER" | "GROUP" | "INVITE" | "ANONYMOUS" | "ORGANIZATION" | (string & {});
export declare const PrincipalType: S.String;
export type RoleType = "VIEWER" | "CONTRIBUTOR" | "OWNER" | "COOWNER" | (string & {});
export declare const RoleType: S.String;
export interface SharePrincipal {
    Id: string;
    Type: PrincipalType;
    Role: RoleType;
}
export declare const SharePrincipal: S.Schema<SharePrincipal>;
export type SharePrincipalList = SharePrincipal[];
export declare const SharePrincipalList: S.$Array<S.Schema<SharePrincipal>>;
export interface NotificationOptions {
    SendEmail?: boolean;
    EmailMessage?: string | redacted.Redacted<string>;
}
export declare const NotificationOptions: S.Schema<NotificationOptions>;
export interface AddResourcePermissionsRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    ResourceId: string;
    Principals: SharePrincipal[];
    NotificationOptions?: NotificationOptions;
}
export declare const AddResourcePermissionsRequest: S.Schema<AddResourcePermissionsRequest>;
export type ShareStatusType = "SUCCESS" | "FAILURE" | (string & {});
export declare const ShareStatusType: S.String;
export interface ShareResult {
    PrincipalId?: string;
    InviteePrincipalId?: string;
    Role?: RoleType;
    Status?: ShareStatusType;
    ShareId?: string;
    StatusMessage?: string | redacted.Redacted<string>;
}
export declare const ShareResult: S.Schema<ShareResult>;
export type ShareResultsList = ShareResult[];
export declare const ShareResultsList: S.$Array<S.Schema<ShareResult>>;
export interface AddResourcePermissionsResponse {
    ShareResults?: ShareResult[];
}
export declare const AddResourcePermissionsResponse: S.Schema<AddResourcePermissionsResponse>;
export type CommentVisibilityType = "PUBLIC" | "PRIVATE" | (string & {});
export declare const CommentVisibilityType: S.String;
export interface CreateCommentRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
    VersionId: string;
    ParentId?: string;
    ThreadId?: string;
    Text: string | redacted.Redacted<string>;
    Visibility?: CommentVisibilityType;
    NotifyCollaborators?: boolean;
}
export declare const CreateCommentRequest: S.Schema<CreateCommentRequest>;
export type CommentStatusType = "DRAFT" | "PUBLISHED" | "DELETED" | (string & {});
export declare const CommentStatusType: S.String;
export interface Comment {
    CommentId: string;
    ParentId?: string;
    ThreadId?: string;
    Text?: string | redacted.Redacted<string>;
    Contributor?: User;
    CreatedTimestamp?: Date;
    Status?: CommentStatusType;
    Visibility?: CommentVisibilityType;
    RecipientId?: string;
}
export declare const Comment: S.Schema<Comment>;
export interface CreateCommentResponse {
    Comment?: Comment;
}
export declare const CreateCommentResponse: S.Schema<CreateCommentResponse>;
export type CustomMetadataMap = {
    [key: string]: string | undefined;
};
export declare const CustomMetadataMap: S.$Record<S.String, S.optional<S.String>>;
export interface CreateCustomMetadataRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    ResourceId: string;
    VersionId?: string;
    CustomMetadata: {
        [key: string]: string | undefined;
    };
}
export declare const CreateCustomMetadataRequest: S.Schema<CreateCustomMetadataRequest>;
export interface CreateCustomMetadataResponse {
}
export declare const CreateCustomMetadataResponse: S.Schema<CreateCustomMetadataResponse>;
export interface CreateFolderRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    Name?: string | redacted.Redacted<string>;
    ParentFolderId: string;
}
export declare const CreateFolderRequest: S.Schema<CreateFolderRequest>;
export type ResourceStateType = "ACTIVE" | "RESTORING" | "RECYCLING" | "RECYCLED" | (string & {});
export declare const ResourceStateType: S.String;
export type SharedLabels = string[];
export declare const SharedLabels: S.$Array<S.String>;
export interface FolderMetadata {
    Id?: string;
    Name?: string | redacted.Redacted<string>;
    CreatorId?: string;
    ParentFolderId?: string;
    CreatedTimestamp?: Date;
    ModifiedTimestamp?: Date;
    ResourceState?: ResourceStateType;
    Signature?: string;
    Labels?: string[];
    Size?: number;
    LatestVersionSize?: number;
}
export declare const FolderMetadata: S.Schema<FolderMetadata>;
export interface CreateFolderResponse {
    Metadata?: FolderMetadata;
}
export declare const CreateFolderResponse: S.Schema<CreateFolderResponse>;
export interface CreateLabelsRequest {
    ResourceId: string;
    Labels: string[];
    AuthenticationToken?: string | redacted.Redacted<string>;
}
export declare const CreateLabelsRequest: S.Schema<CreateLabelsRequest>;
export interface CreateLabelsResponse {
}
export declare const CreateLabelsResponse: S.Schema<CreateLabelsResponse>;
export type SubscriptionProtocolType = "HTTPS" | "SQS" | (string & {});
export declare const SubscriptionProtocolType: S.String;
export type SubscriptionType = "ALL" | (string & {});
export declare const SubscriptionType: S.String;
export interface CreateNotificationSubscriptionRequest {
    OrganizationId: string;
    Endpoint: string;
    Protocol: SubscriptionProtocolType;
    SubscriptionType: SubscriptionType;
}
export declare const CreateNotificationSubscriptionRequest: S.Schema<CreateNotificationSubscriptionRequest>;
export interface Subscription {
    SubscriptionId?: string;
    EndPoint?: string;
    Protocol?: SubscriptionProtocolType;
}
export declare const Subscription: S.Schema<Subscription>;
export interface CreateNotificationSubscriptionResponse {
    Subscription?: Subscription;
}
export declare const CreateNotificationSubscriptionResponse: S.Schema<CreateNotificationSubscriptionResponse>;
export interface CreateUserRequest {
    OrganizationId?: string;
    Username: string | redacted.Redacted<string>;
    EmailAddress?: string | redacted.Redacted<string>;
    GivenName: string | redacted.Redacted<string>;
    Surname: string | redacted.Redacted<string>;
    Password: string | redacted.Redacted<string>;
    TimeZoneId?: string;
    StorageRule?: StorageRuleType;
    AuthenticationToken?: string | redacted.Redacted<string>;
}
export declare const CreateUserRequest: S.Schema<CreateUserRequest>;
export interface CreateUserResponse {
    User?: User;
}
export declare const CreateUserResponse: S.Schema<CreateUserResponse>;
export interface DeactivateUserRequest {
    UserId: string;
    AuthenticationToken?: string | redacted.Redacted<string>;
}
export declare const DeactivateUserRequest: S.Schema<DeactivateUserRequest>;
export interface DeactivateUserResponse {
}
export declare const DeactivateUserResponse: S.Schema<DeactivateUserResponse>;
export interface DeleteCommentRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
    VersionId: string;
    CommentId: string;
}
export declare const DeleteCommentRequest: S.Schema<DeleteCommentRequest>;
export interface DeleteCommentResponse {
}
export declare const DeleteCommentResponse: S.Schema<DeleteCommentResponse>;
export type CustomMetadataKeyList = string[];
export declare const CustomMetadataKeyList: S.$Array<S.String>;
export interface DeleteCustomMetadataRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    ResourceId: string;
    VersionId?: string;
    Keys?: string[];
    DeleteAll?: boolean;
}
export declare const DeleteCustomMetadataRequest: S.Schema<DeleteCustomMetadataRequest>;
export interface DeleteCustomMetadataResponse {
}
export declare const DeleteCustomMetadataResponse: S.Schema<DeleteCustomMetadataResponse>;
export interface DeleteDocumentRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
}
export declare const DeleteDocumentRequest: S.Schema<DeleteDocumentRequest>;
export interface DeleteDocumentResponse {
}
export declare const DeleteDocumentResponse: S.Schema<DeleteDocumentResponse>;
export interface DeleteDocumentVersionRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
    VersionId: string;
    DeletePriorVersions: boolean;
}
export declare const DeleteDocumentVersionRequest: S.Schema<DeleteDocumentVersionRequest>;
export interface DeleteDocumentVersionResponse {
}
export declare const DeleteDocumentVersionResponse: S.Schema<DeleteDocumentVersionResponse>;
export interface DeleteFolderRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    FolderId: string;
}
export declare const DeleteFolderRequest: S.Schema<DeleteFolderRequest>;
export interface DeleteFolderResponse {
}
export declare const DeleteFolderResponse: S.Schema<DeleteFolderResponse>;
export interface DeleteFolderContentsRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    FolderId: string;
}
export declare const DeleteFolderContentsRequest: S.Schema<DeleteFolderContentsRequest>;
export interface DeleteFolderContentsResponse {
}
export declare const DeleteFolderContentsResponse: S.Schema<DeleteFolderContentsResponse>;
export interface DeleteLabelsRequest {
    ResourceId: string;
    AuthenticationToken?: string | redacted.Redacted<string>;
    Labels?: string[];
    DeleteAll?: boolean;
}
export declare const DeleteLabelsRequest: S.Schema<DeleteLabelsRequest>;
export interface DeleteLabelsResponse {
}
export declare const DeleteLabelsResponse: S.Schema<DeleteLabelsResponse>;
export interface DeleteNotificationSubscriptionRequest {
    SubscriptionId: string;
    OrganizationId: string;
}
export declare const DeleteNotificationSubscriptionRequest: S.Schema<DeleteNotificationSubscriptionRequest>;
export interface DeleteNotificationSubscriptionResponse {
}
export declare const DeleteNotificationSubscriptionResponse: S.Schema<DeleteNotificationSubscriptionResponse>;
export interface DeleteUserRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    UserId: string;
}
export declare const DeleteUserRequest: S.Schema<DeleteUserRequest>;
export interface DeleteUserResponse {
}
export declare const DeleteUserResponse: S.Schema<DeleteUserResponse>;
export interface DescribeActivitiesRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    StartTime?: Date;
    EndTime?: Date;
    OrganizationId?: string;
    ActivityTypes?: string;
    ResourceId?: string;
    UserId?: string;
    IncludeIndirectActivities?: boolean;
    Limit?: number;
    Marker?: string;
}
export declare const DescribeActivitiesRequest: S.Schema<DescribeActivitiesRequest>;
export type ActivityType = "DOCUMENT_CHECKED_IN" | "DOCUMENT_CHECKED_OUT" | "DOCUMENT_RENAMED" | "DOCUMENT_VERSION_UPLOADED" | "DOCUMENT_VERSION_DELETED" | "DOCUMENT_VERSION_VIEWED" | "DOCUMENT_VERSION_DOWNLOADED" | "DOCUMENT_RECYCLED" | "DOCUMENT_RESTORED" | "DOCUMENT_REVERTED" | "DOCUMENT_SHARED" | "DOCUMENT_UNSHARED" | "DOCUMENT_SHARE_PERMISSION_CHANGED" | "DOCUMENT_SHAREABLE_LINK_CREATED" | "DOCUMENT_SHAREABLE_LINK_REMOVED" | "DOCUMENT_SHAREABLE_LINK_PERMISSION_CHANGED" | "DOCUMENT_MOVED" | "DOCUMENT_COMMENT_ADDED" | "DOCUMENT_COMMENT_DELETED" | "DOCUMENT_ANNOTATION_ADDED" | "DOCUMENT_ANNOTATION_DELETED" | "FOLDER_CREATED" | "FOLDER_DELETED" | "FOLDER_RENAMED" | "FOLDER_RECYCLED" | "FOLDER_RESTORED" | "FOLDER_SHARED" | "FOLDER_UNSHARED" | "FOLDER_SHARE_PERMISSION_CHANGED" | "FOLDER_SHAREABLE_LINK_CREATED" | "FOLDER_SHAREABLE_LINK_REMOVED" | "FOLDER_SHAREABLE_LINK_PERMISSION_CHANGED" | "FOLDER_MOVED" | (string & {});
export declare const ActivityType: S.String;
export interface UserMetadata {
    Id?: string;
    Username?: string | redacted.Redacted<string>;
    GivenName?: string | redacted.Redacted<string>;
    Surname?: string | redacted.Redacted<string>;
    EmailAddress?: string | redacted.Redacted<string>;
}
export declare const UserMetadata: S.Schema<UserMetadata>;
export type UserMetadataList = UserMetadata[];
export declare const UserMetadataList: S.$Array<S.Schema<UserMetadata>>;
export interface GroupMetadata {
    Id?: string;
    Name?: string;
}
export declare const GroupMetadata: S.Schema<GroupMetadata>;
export type GroupMetadataList = GroupMetadata[];
export declare const GroupMetadataList: S.$Array<S.Schema<GroupMetadata>>;
export interface Participants {
    Users?: UserMetadata[];
    Groups?: GroupMetadata[];
}
export declare const Participants: S.Schema<Participants>;
export type ResourceType = "FOLDER" | "DOCUMENT" | (string & {});
export declare const ResourceType: S.String;
export interface ResourceMetadata {
    Type?: ResourceType;
    Name?: string | redacted.Redacted<string>;
    OriginalName?: string | redacted.Redacted<string>;
    Id?: string;
    VersionId?: string;
    Owner?: UserMetadata;
    ParentId?: string;
}
export declare const ResourceMetadata: S.Schema<ResourceMetadata>;
export interface CommentMetadata {
    CommentId?: string;
    Contributor?: User;
    CreatedTimestamp?: Date;
    CommentStatus?: CommentStatusType;
    RecipientId?: string;
    ContributorId?: string;
}
export declare const CommentMetadata: S.Schema<CommentMetadata>;
export interface Activity {
    Type?: ActivityType;
    TimeStamp?: Date;
    IsIndirectActivity?: boolean;
    OrganizationId?: string;
    Initiator?: UserMetadata;
    Participants?: Participants;
    ResourceMetadata?: ResourceMetadata;
    OriginalParent?: ResourceMetadata;
    CommentMetadata?: CommentMetadata;
}
export declare const Activity: S.Schema<Activity>;
export type UserActivities = Activity[];
export declare const UserActivities: S.$Array<S.Schema<Activity>>;
export interface DescribeActivitiesResponse {
    UserActivities?: Activity[];
    Marker?: string;
}
export declare const DescribeActivitiesResponse: S.Schema<DescribeActivitiesResponse>;
export interface DescribeCommentsRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
    VersionId: string;
    Limit?: number;
    Marker?: string;
}
export declare const DescribeCommentsRequest: S.Schema<DescribeCommentsRequest>;
export type CommentList = Comment[];
export declare const CommentList: S.$Array<S.Schema<Comment>>;
export interface DescribeCommentsResponse {
    Comments?: Comment[];
    Marker?: string;
}
export declare const DescribeCommentsResponse: S.Schema<DescribeCommentsResponse>;
export interface DescribeDocumentVersionsRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
    Marker?: string;
    Limit?: number;
    Include?: string;
    Fields?: string;
}
export declare const DescribeDocumentVersionsRequest: S.Schema<DescribeDocumentVersionsRequest>;
export type DocumentStatusType = "INITIALIZED" | "ACTIVE" | (string & {});
export declare const DocumentStatusType: S.String;
export type DocumentThumbnailType = "SMALL" | "SMALL_HQ" | "LARGE" | (string & {});
export declare const DocumentThumbnailType: S.String;
export type DocumentThumbnailUrlMap = {
    [key in DocumentThumbnailType]?: string | redacted.Redacted<string>;
};
export declare const DocumentThumbnailUrlMap: S.$Record<S.String, S.optional<S.Schema<string | redacted.Redacted<string>>>>;
export type DocumentSourceType = "ORIGINAL" | "WITH_COMMENTS" | (string & {});
export declare const DocumentSourceType: S.String;
export type DocumentSourceUrlMap = {
    [key in DocumentSourceType]?: string | redacted.Redacted<string>;
};
export declare const DocumentSourceUrlMap: S.$Record<S.String, S.optional<S.Schema<string | redacted.Redacted<string>>>>;
export interface DocumentVersionMetadata {
    Id?: string;
    Name?: string | redacted.Redacted<string>;
    ContentType?: string;
    Size?: number;
    Signature?: string;
    Status?: DocumentStatusType;
    CreatedTimestamp?: Date;
    ModifiedTimestamp?: Date;
    ContentCreatedTimestamp?: Date;
    ContentModifiedTimestamp?: Date;
    CreatorId?: string;
    Thumbnail?: {
        [key: string]: string | redacted.Redacted<string> | undefined;
    };
    Source?: {
        [key: string]: string | redacted.Redacted<string> | undefined;
    };
}
export declare const DocumentVersionMetadata: S.Schema<DocumentVersionMetadata>;
export type DocumentVersionMetadataList = DocumentVersionMetadata[];
export declare const DocumentVersionMetadataList: S.$Array<S.Schema<DocumentVersionMetadata>>;
export interface DescribeDocumentVersionsResponse {
    DocumentVersions?: DocumentVersionMetadata[];
    Marker?: string;
}
export declare const DescribeDocumentVersionsResponse: S.Schema<DescribeDocumentVersionsResponse>;
export type ResourceSortType = "DATE" | "NAME" | (string & {});
export declare const ResourceSortType: S.String;
export type OrderType = "ASCENDING" | "DESCENDING" | (string & {});
export declare const OrderType: S.String;
export type FolderContentType = "ALL" | "DOCUMENT" | "FOLDER" | (string & {});
export declare const FolderContentType: S.String;
export interface DescribeFolderContentsRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    FolderId: string;
    Sort?: ResourceSortType;
    Order?: OrderType;
    Limit?: number;
    Marker?: string;
    Type?: FolderContentType;
    Include?: string;
}
export declare const DescribeFolderContentsRequest: S.Schema<DescribeFolderContentsRequest>;
export type FolderMetadataList = FolderMetadata[];
export declare const FolderMetadataList: S.$Array<S.Schema<FolderMetadata>>;
export interface DocumentMetadata {
    Id?: string;
    CreatorId?: string;
    ParentFolderId?: string;
    CreatedTimestamp?: Date;
    ModifiedTimestamp?: Date;
    LatestVersionMetadata?: DocumentVersionMetadata;
    ResourceState?: ResourceStateType;
    Labels?: string[];
}
export declare const DocumentMetadata: S.Schema<DocumentMetadata>;
export type DocumentMetadataList = DocumentMetadata[];
export declare const DocumentMetadataList: S.$Array<S.Schema<DocumentMetadata>>;
export interface DescribeFolderContentsResponse {
    Folders?: FolderMetadata[];
    Documents?: DocumentMetadata[];
    Marker?: string;
}
export declare const DescribeFolderContentsResponse: S.Schema<DescribeFolderContentsResponse>;
export interface DescribeGroupsRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    SearchQuery: string | redacted.Redacted<string>;
    OrganizationId?: string;
    Marker?: string;
    Limit?: number;
}
export declare const DescribeGroupsRequest: S.Schema<DescribeGroupsRequest>;
export interface DescribeGroupsResponse {
    Groups?: GroupMetadata[];
    Marker?: string;
}
export declare const DescribeGroupsResponse: S.Schema<DescribeGroupsResponse>;
export interface DescribeNotificationSubscriptionsRequest {
    OrganizationId: string;
    Marker?: string;
    Limit?: number;
}
export declare const DescribeNotificationSubscriptionsRequest: S.Schema<DescribeNotificationSubscriptionsRequest>;
export type SubscriptionList = Subscription[];
export declare const SubscriptionList: S.$Array<S.Schema<Subscription>>;
export interface DescribeNotificationSubscriptionsResponse {
    Subscriptions?: Subscription[];
    Marker?: string;
}
export declare const DescribeNotificationSubscriptionsResponse: S.Schema<DescribeNotificationSubscriptionsResponse>;
export interface DescribeResourcePermissionsRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    ResourceId: string;
    PrincipalId?: string;
    Limit?: number;
    Marker?: string;
}
export declare const DescribeResourcePermissionsRequest: S.Schema<DescribeResourcePermissionsRequest>;
export type RolePermissionType = "DIRECT" | "INHERITED" | (string & {});
export declare const RolePermissionType: S.String;
export interface PermissionInfo {
    Role?: RoleType;
    Type?: RolePermissionType;
}
export declare const PermissionInfo: S.Schema<PermissionInfo>;
export type PermissionInfoList = PermissionInfo[];
export declare const PermissionInfoList: S.$Array<S.Schema<PermissionInfo>>;
export interface Principal {
    Id?: string;
    Type?: PrincipalType;
    Roles?: PermissionInfo[];
}
export declare const Principal: S.Schema<Principal>;
export type PrincipalList = Principal[];
export declare const PrincipalList: S.$Array<S.Schema<Principal>>;
export interface DescribeResourcePermissionsResponse {
    Principals?: Principal[];
    Marker?: string;
}
export declare const DescribeResourcePermissionsResponse: S.Schema<DescribeResourcePermissionsResponse>;
export interface DescribeRootFoldersRequest {
    AuthenticationToken: string | redacted.Redacted<string>;
    Limit?: number;
    Marker?: string;
}
export declare const DescribeRootFoldersRequest: S.Schema<DescribeRootFoldersRequest>;
export interface DescribeRootFoldersResponse {
    Folders?: FolderMetadata[];
    Marker?: string;
}
export declare const DescribeRootFoldersResponse: S.Schema<DescribeRootFoldersResponse>;
export type UserFilterType = "ALL" | "ACTIVE_PENDING" | (string & {});
export declare const UserFilterType: S.String;
export type UserSortType = "USER_NAME" | "FULL_NAME" | "STORAGE_LIMIT" | "USER_STATUS" | "STORAGE_USED" | (string & {});
export declare const UserSortType: S.String;
export interface DescribeUsersRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    OrganizationId?: string;
    UserIds?: string;
    Query?: string | redacted.Redacted<string>;
    Include?: UserFilterType;
    Order?: OrderType;
    Sort?: UserSortType;
    Marker?: string;
    Limit?: number;
    Fields?: string;
}
export declare const DescribeUsersRequest: S.Schema<DescribeUsersRequest>;
export type OrganizationUserList = User[];
export declare const OrganizationUserList: S.$Array<S.Schema<User>>;
export interface DescribeUsersResponse {
    Users?: User[];
    TotalNumberOfUsers?: number;
    Marker?: string;
}
export declare const DescribeUsersResponse: S.Schema<DescribeUsersResponse>;
export interface GetCurrentUserRequest {
    AuthenticationToken: string | redacted.Redacted<string>;
}
export declare const GetCurrentUserRequest: S.Schema<GetCurrentUserRequest>;
export interface GetCurrentUserResponse {
    User?: User;
}
export declare const GetCurrentUserResponse: S.Schema<GetCurrentUserResponse>;
export interface GetDocumentRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
    IncludeCustomMetadata?: boolean;
}
export declare const GetDocumentRequest: S.Schema<GetDocumentRequest>;
export interface GetDocumentResponse {
    Metadata?: DocumentMetadata;
    CustomMetadata?: {
        [key: string]: string | undefined;
    };
}
export declare const GetDocumentResponse: S.Schema<GetDocumentResponse>;
export interface GetDocumentPathRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
    Limit?: number;
    Fields?: string;
    Marker?: string;
}
export declare const GetDocumentPathRequest: S.Schema<GetDocumentPathRequest>;
export interface ResourcePathComponent {
    Id?: string;
    Name?: string | redacted.Redacted<string>;
}
export declare const ResourcePathComponent: S.Schema<ResourcePathComponent>;
export type ResourcePathComponentList = ResourcePathComponent[];
export declare const ResourcePathComponentList: S.$Array<S.Schema<ResourcePathComponent>>;
export interface ResourcePath {
    Components?: ResourcePathComponent[];
}
export declare const ResourcePath: S.Schema<ResourcePath>;
export interface GetDocumentPathResponse {
    Path?: ResourcePath;
}
export declare const GetDocumentPathResponse: S.Schema<GetDocumentPathResponse>;
export interface GetDocumentVersionRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
    VersionId: string;
    Fields?: string;
    IncludeCustomMetadata?: boolean;
}
export declare const GetDocumentVersionRequest: S.Schema<GetDocumentVersionRequest>;
export interface GetDocumentVersionResponse {
    Metadata?: DocumentVersionMetadata;
    CustomMetadata?: {
        [key: string]: string | undefined;
    };
}
export declare const GetDocumentVersionResponse: S.Schema<GetDocumentVersionResponse>;
export interface GetFolderRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    FolderId: string;
    IncludeCustomMetadata?: boolean;
}
export declare const GetFolderRequest: S.Schema<GetFolderRequest>;
export interface GetFolderResponse {
    Metadata?: FolderMetadata;
    CustomMetadata?: {
        [key: string]: string | undefined;
    };
}
export declare const GetFolderResponse: S.Schema<GetFolderResponse>;
export interface GetFolderPathRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    FolderId: string;
    Limit?: number;
    Fields?: string;
    Marker?: string;
}
export declare const GetFolderPathRequest: S.Schema<GetFolderPathRequest>;
export interface GetFolderPathResponse {
    Path?: ResourcePath;
}
export declare const GetFolderPathResponse: S.Schema<GetFolderPathResponse>;
export type ResourceCollectionType = "SHARED_WITH_ME" | (string & {});
export declare const ResourceCollectionType: S.String;
export interface GetResourcesRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    UserId?: string;
    CollectionType?: ResourceCollectionType;
    Limit?: number;
    Marker?: string;
}
export declare const GetResourcesRequest: S.Schema<GetResourcesRequest>;
export interface GetResourcesResponse {
    Folders?: FolderMetadata[];
    Documents?: DocumentMetadata[];
    Marker?: string;
}
export declare const GetResourcesResponse: S.Schema<GetResourcesResponse>;
export interface InitiateDocumentVersionUploadRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    Id?: string;
    Name?: string | redacted.Redacted<string>;
    ContentCreatedTimestamp?: Date;
    ContentModifiedTimestamp?: Date;
    ContentType?: string;
    DocumentSizeInBytes?: number;
    ParentFolderId?: string;
}
export declare const InitiateDocumentVersionUploadRequest: S.Schema<InitiateDocumentVersionUploadRequest>;
export type SignedHeaderMap = {
    [key: string]: string | undefined;
};
export declare const SignedHeaderMap: S.$Record<S.String, S.optional<S.String>>;
export interface UploadMetadata {
    UploadUrl?: string | redacted.Redacted<string>;
    SignedHeaders?: {
        [key: string]: string | undefined;
    };
}
export declare const UploadMetadata: S.Schema<UploadMetadata>;
export interface InitiateDocumentVersionUploadResponse {
    Metadata?: DocumentMetadata;
    UploadMetadata?: UploadMetadata;
}
export declare const InitiateDocumentVersionUploadResponse: S.Schema<InitiateDocumentVersionUploadResponse>;
export interface RemoveAllResourcePermissionsRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    ResourceId: string;
}
export declare const RemoveAllResourcePermissionsRequest: S.Schema<RemoveAllResourcePermissionsRequest>;
export interface RemoveAllResourcePermissionsResponse {
}
export declare const RemoveAllResourcePermissionsResponse: S.Schema<RemoveAllResourcePermissionsResponse>;
export interface RemoveResourcePermissionRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    ResourceId: string;
    PrincipalId: string;
    PrincipalType?: PrincipalType;
}
export declare const RemoveResourcePermissionRequest: S.Schema<RemoveResourcePermissionRequest>;
export interface RemoveResourcePermissionResponse {
}
export declare const RemoveResourcePermissionResponse: S.Schema<RemoveResourcePermissionResponse>;
export interface RestoreDocumentVersionsRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
}
export declare const RestoreDocumentVersionsRequest: S.Schema<RestoreDocumentVersionsRequest>;
export interface RestoreDocumentVersionsResponse {
}
export declare const RestoreDocumentVersionsResponse: S.Schema<RestoreDocumentVersionsResponse>;
export type SearchQueryScopeType = "NAME" | "CONTENT" | (string & {});
export declare const SearchQueryScopeType: S.String;
export type SearchQueryScopeTypeList = SearchQueryScopeType[];
export declare const SearchQueryScopeTypeList: S.$Array<S.String>;
export type AdditionalResponseFieldType = "WEBURL" | (string & {});
export declare const AdditionalResponseFieldType: S.String;
export type AdditionalResponseFieldsList = AdditionalResponseFieldType[];
export declare const AdditionalResponseFieldsList: S.$Array<S.String>;
export type LanguageCodeType = "AR" | "BG" | "BN" | "DA" | "DE" | "CS" | "EL" | "EN" | "ES" | "FA" | "FI" | "FR" | "HI" | "HU" | "ID" | "IT" | "JA" | "KO" | "LT" | "LV" | "NL" | "NO" | "PT" | "RO" | "RU" | "SV" | "SW" | "TH" | "TR" | "ZH" | "DEFAULT" | (string & {});
export declare const LanguageCodeType: S.String;
export type TextLocaleTypeList = LanguageCodeType[];
export declare const TextLocaleTypeList: S.$Array<S.String>;
export type ContentCategoryType = "IMAGE" | "DOCUMENT" | "PDF" | "SPREADSHEET" | "PRESENTATION" | "AUDIO" | "VIDEO" | "SOURCE_CODE" | "OTHER" | (string & {});
export declare const ContentCategoryType: S.String;
export type SearchContentCategoryTypeList = ContentCategoryType[];
export declare const SearchContentCategoryTypeList: S.$Array<S.String>;
export type SearchResourceType = "FOLDER" | "DOCUMENT" | "COMMENT" | "DOCUMENT_VERSION" | (string & {});
export declare const SearchResourceType: S.String;
export type SearchResourceTypeList = SearchResourceType[];
export declare const SearchResourceTypeList: S.$Array<S.String>;
export type SearchLabelList = string[];
export declare const SearchLabelList: S.$Array<S.String>;
export type PrincipalRoleType = "VIEWER" | "CONTRIBUTOR" | "OWNER" | "COOWNER" | (string & {});
export declare const PrincipalRoleType: S.String;
export type SearchPrincipalRoleList = PrincipalRoleType[];
export declare const SearchPrincipalRoleList: S.$Array<S.String>;
export interface SearchPrincipalType {
    Id: string;
    Roles?: PrincipalRoleType[];
}
export declare const SearchPrincipalType: S.Schema<SearchPrincipalType>;
export type SearchPrincipalTypeList = SearchPrincipalType[];
export declare const SearchPrincipalTypeList: S.$Array<S.Schema<SearchPrincipalType>>;
export type SearchAncestorIdList = string[];
export declare const SearchAncestorIdList: S.$Array<S.String>;
export type SearchCollectionType = "OWNED" | "SHARED_WITH_ME" | (string & {});
export declare const SearchCollectionType: S.String;
export type SearchCollectionTypeList = SearchCollectionType[];
export declare const SearchCollectionTypeList: S.$Array<S.String>;
export interface LongRangeType {
    StartValue?: number;
    EndValue?: number;
}
export declare const LongRangeType: S.Schema<LongRangeType>;
export interface DateRangeType {
    StartValue?: Date;
    EndValue?: Date;
}
export declare const DateRangeType: S.Schema<DateRangeType>;
export interface Filters {
    TextLocales?: LanguageCodeType[];
    ContentCategories?: ContentCategoryType[];
    ResourceTypes?: SearchResourceType[];
    Labels?: string[];
    Principals?: SearchPrincipalType[];
    AncestorIds?: string[];
    SearchCollectionTypes?: SearchCollectionType[];
    SizeRange?: LongRangeType;
    CreatedRange?: DateRangeType;
    ModifiedRange?: DateRangeType;
}
export declare const Filters: S.Schema<Filters>;
export type OrderByFieldType = "RELEVANCE" | "NAME" | "SIZE" | "CREATED_TIMESTAMP" | "MODIFIED_TIMESTAMP" | (string & {});
export declare const OrderByFieldType: S.String;
export type SortOrder = "ASC" | "DESC" | (string & {});
export declare const SortOrder: S.String;
export interface SearchSortResult {
    Field?: OrderByFieldType;
    Order?: SortOrder;
}
export declare const SearchSortResult: S.Schema<SearchSortResult>;
export type SearchResultSortList = SearchSortResult[];
export declare const SearchResultSortList: S.$Array<S.Schema<SearchSortResult>>;
export interface SearchResourcesRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    QueryText?: string | redacted.Redacted<string>;
    QueryScopes?: SearchQueryScopeType[];
    OrganizationId?: string;
    AdditionalResponseFields?: AdditionalResponseFieldType[];
    Filters?: Filters;
    OrderBy?: SearchSortResult[];
    Limit?: number;
    Marker?: string;
}
export declare const SearchResourcesRequest: S.Schema<SearchResourcesRequest>;
export type ResponseItemType = "DOCUMENT" | "FOLDER" | "COMMENT" | "DOCUMENT_VERSION" | (string & {});
export declare const ResponseItemType: S.String;
export interface ResponseItem {
    ResourceType?: ResponseItemType;
    WebUrl?: string | redacted.Redacted<string>;
    DocumentMetadata?: DocumentMetadata;
    FolderMetadata?: FolderMetadata;
    CommentMetadata?: CommentMetadata;
    DocumentVersionMetadata?: DocumentVersionMetadata;
}
export declare const ResponseItem: S.Schema<ResponseItem>;
export type ResponseItemsList = ResponseItem[];
export declare const ResponseItemsList: S.$Array<S.Schema<ResponseItem>>;
export interface SearchResourcesResponse {
    Items?: ResponseItem[];
    Marker?: string;
}
export declare const SearchResourcesResponse: S.Schema<SearchResourcesResponse>;
export interface UpdateDocumentRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
    Name?: string | redacted.Redacted<string>;
    ParentFolderId?: string;
    ResourceState?: ResourceStateType;
}
export declare const UpdateDocumentRequest: S.Schema<UpdateDocumentRequest>;
export interface UpdateDocumentResponse {
}
export declare const UpdateDocumentResponse: S.Schema<UpdateDocumentResponse>;
export type DocumentVersionStatus = "ACTIVE" | (string & {});
export declare const DocumentVersionStatus: S.String;
export interface UpdateDocumentVersionRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    DocumentId: string;
    VersionId: string;
    VersionStatus?: DocumentVersionStatus;
}
export declare const UpdateDocumentVersionRequest: S.Schema<UpdateDocumentVersionRequest>;
export interface UpdateDocumentVersionResponse {
}
export declare const UpdateDocumentVersionResponse: S.Schema<UpdateDocumentVersionResponse>;
export interface UpdateFolderRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    FolderId: string;
    Name?: string | redacted.Redacted<string>;
    ParentFolderId?: string;
    ResourceState?: ResourceStateType;
}
export declare const UpdateFolderRequest: S.Schema<UpdateFolderRequest>;
export interface UpdateFolderResponse {
}
export declare const UpdateFolderResponse: S.Schema<UpdateFolderResponse>;
export type BooleanEnumType = "TRUE" | "FALSE" | (string & {});
export declare const BooleanEnumType: S.String;
export interface UpdateUserRequest {
    AuthenticationToken?: string | redacted.Redacted<string>;
    UserId: string;
    GivenName?: string | redacted.Redacted<string>;
    Surname?: string | redacted.Redacted<string>;
    Type?: UserType;
    StorageRule?: StorageRuleType;
    TimeZoneId?: string;
    Locale?: LocaleType;
    GrantPoweruserPrivileges?: BooleanEnumType;
}
export declare const UpdateUserRequest: S.Schema<UpdateUserRequest>;
export interface UpdateUserResponse {
    User?: User;
}
export declare const UpdateUserResponse: S.Schema<UpdateUserResponse>;
declare const ConcurrentModificationException_base: S.Class<ConcurrentModificationException, S.TaggedStruct<"ConcurrentModificationException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConcurrentModificationException extends ConcurrentModificationException_base {
}
declare const EntityNotExistsException_base: S.Class<EntityNotExistsException, S.TaggedStruct<"EntityNotExistsException", {
    readonly Message: S.optional<S.String>;
    readonly EntityIds: S.optional<S.$Array<S.String>>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class EntityNotExistsException extends EntityNotExistsException_base {
}
declare const FailedDependencyException_base: S.Class<FailedDependencyException, S.TaggedStruct<"FailedDependencyException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError>;
export declare class FailedDependencyException extends FailedDependencyException_base {
}
declare const ProhibitedStateException_base: S.Class<ProhibitedStateException, S.TaggedStruct<"ProhibitedStateException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ProhibitedStateException extends ProhibitedStateException_base {
}
declare const ServiceUnavailableException_base: S.Class<ServiceUnavailableException, S.TaggedStruct<"ServiceUnavailableException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class ServiceUnavailableException extends ServiceUnavailableException_base {
}
declare const UnauthorizedOperationException_base: S.Class<UnauthorizedOperationException, S.TaggedStruct<"UnauthorizedOperationException", {
    readonly Message: S.optional<S.String>;
    readonly Code: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class UnauthorizedOperationException extends UnauthorizedOperationException_base {
}
declare const UnauthorizedResourceAccessException_base: S.Class<UnauthorizedResourceAccessException, S.TaggedStruct<"UnauthorizedResourceAccessException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class UnauthorizedResourceAccessException extends UnauthorizedResourceAccessException_base {
}
declare const DocumentLockedForCommentsException_base: S.Class<DocumentLockedForCommentsException, S.TaggedStruct<"DocumentLockedForCommentsException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class DocumentLockedForCommentsException extends DocumentLockedForCommentsException_base {
}
declare const InvalidCommentOperationException_base: S.Class<InvalidCommentOperationException, S.TaggedStruct<"InvalidCommentOperationException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class InvalidCommentOperationException extends InvalidCommentOperationException_base {
}
declare const CustomMetadataLimitExceededException_base: S.Class<CustomMetadataLimitExceededException, S.TaggedStruct<"CustomMetadataLimitExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class CustomMetadataLimitExceededException extends CustomMetadataLimitExceededException_base {
}
declare const ConflictingOperationException_base: S.Class<ConflictingOperationException, S.TaggedStruct<"ConflictingOperationException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictingOperationException extends ConflictingOperationException_base {
}
declare const EntityAlreadyExistsException_base: S.Class<EntityAlreadyExistsException, S.TaggedStruct<"EntityAlreadyExistsException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AlreadyExistsError: true;
    };
});
export declare class EntityAlreadyExistsException extends EntityAlreadyExistsException_base {
}
declare const LimitExceededException_base: S.Class<LimitExceededException, S.TaggedStruct<"LimitExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class LimitExceededException extends LimitExceededException_base {
}
declare const TooManyLabelsException_base: S.Class<TooManyLabelsException, S.TaggedStruct<"TooManyLabelsException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class TooManyLabelsException extends TooManyLabelsException_base {
}
declare const InvalidArgumentException_base: S.Class<InvalidArgumentException, S.TaggedStruct<"InvalidArgumentException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidArgumentException extends InvalidArgumentException_base {
}
declare const TooManySubscriptionsException_base: S.Class<TooManySubscriptionsException, S.TaggedStruct<"TooManySubscriptionsException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class TooManySubscriptionsException extends TooManySubscriptionsException_base {
}
declare const InvalidOperationException_base: S.Class<InvalidOperationException, S.TaggedStruct<"InvalidOperationException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidOperationException extends InvalidOperationException_base {
}
declare const InvalidPasswordException_base: S.Class<InvalidPasswordException, S.TaggedStruct<"InvalidPasswordException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class InvalidPasswordException extends InvalidPasswordException_base {
}
declare const RequestedEntityTooLargeException_base: S.Class<RequestedEntityTooLargeException, S.TaggedStruct<"RequestedEntityTooLargeException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class RequestedEntityTooLargeException extends RequestedEntityTooLargeException_base {
}
declare const DraftUploadOutOfSyncException_base: S.Class<DraftUploadOutOfSyncException, S.TaggedStruct<"DraftUploadOutOfSyncException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class DraftUploadOutOfSyncException extends DraftUploadOutOfSyncException_base {
}
declare const ResourceAlreadyCheckedOutException_base: S.Class<ResourceAlreadyCheckedOutException, S.TaggedStruct<"ResourceAlreadyCheckedOutException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ResourceAlreadyCheckedOutException extends ResourceAlreadyCheckedOutException_base {
}
declare const StorageLimitExceededException_base: S.Class<StorageLimitExceededException, S.TaggedStruct<"StorageLimitExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class StorageLimitExceededException extends StorageLimitExceededException_base {
}
declare const StorageLimitWillExceedException_base: S.Class<StorageLimitWillExceedException, S.TaggedStruct<"StorageLimitWillExceedException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class StorageLimitWillExceedException extends StorageLimitWillExceedException_base {
}
declare const DeactivatingLastSystemUserException_base: S.Class<DeactivatingLastSystemUserException, S.TaggedStruct<"DeactivatingLastSystemUserException", {
    readonly Message: S.optional<S.String>;
    readonly Code: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class DeactivatingLastSystemUserException extends DeactivatingLastSystemUserException_base {
}
declare const IllegalUserStateException_base: S.Class<IllegalUserStateException, S.TaggedStruct<"IllegalUserStateException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class IllegalUserStateException extends IllegalUserStateException_base {
}
export type AbortDocumentVersionUploadError = ConcurrentModificationException | EntityNotExistsException | FailedDependencyException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Aborts the upload of the specified document version that was previously initiated
 * by InitiateDocumentVersionUpload. The client should make this call
 * only when it no longer intends to upload the document version, or fails to do
 * so.
 */
export declare const abortDocumentVersionUpload: API.OperationMethod<AbortDocumentVersionUploadRequest, AbortDocumentVersionUploadResponse, AbortDocumentVersionUploadError, Credentials | Region | HttpClient.HttpClient>;
export type ActivateUserError = EntityNotExistsException | FailedDependencyException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Activates the specified user. Only active users can access Amazon
 * WorkDocs.
 */
export declare const activateUser: API.OperationMethod<ActivateUserRequest, ActivateUserResponse, ActivateUserError, Credentials | Region | HttpClient.HttpClient>;
export type AddResourcePermissionsError = FailedDependencyException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Creates a set of permissions for the specified folder or document. The resource
 * permissions are overwritten if the principals already have different
 * permissions.
 */
export declare const addResourcePermissions: API.OperationMethod<AddResourcePermissionsRequest, AddResourcePermissionsResponse, AddResourcePermissionsError, Credentials | Region | HttpClient.HttpClient>;
export type CreateCommentError = DocumentLockedForCommentsException | EntityNotExistsException | FailedDependencyException | InvalidCommentOperationException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Adds a new comment to the specified document version.
 */
export declare const createComment: API.OperationMethod<CreateCommentRequest, CreateCommentResponse, CreateCommentError, Credentials | Region | HttpClient.HttpClient>;
export type CreateCustomMetadataError = CustomMetadataLimitExceededException | EntityNotExistsException | FailedDependencyException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Adds one or more custom properties to the specified resource (a folder, document,
 * or version).
 */
export declare const createCustomMetadata: API.OperationMethod<CreateCustomMetadataRequest, CreateCustomMetadataResponse, CreateCustomMetadataError, Credentials | Region | HttpClient.HttpClient>;
export type CreateFolderError = ConcurrentModificationException | ConflictingOperationException | EntityAlreadyExistsException | EntityNotExistsException | FailedDependencyException | LimitExceededException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Creates a folder with the specified name and parent folder.
 */
export declare const createFolder: API.OperationMethod<CreateFolderRequest, CreateFolderResponse, CreateFolderError, Credentials | Region | HttpClient.HttpClient>;
export type CreateLabelsError = EntityNotExistsException | FailedDependencyException | ServiceUnavailableException | TooManyLabelsException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Adds the specified list of labels to the given resource (a document or
 * folder)
 */
export declare const createLabels: API.OperationMethod<CreateLabelsRequest, CreateLabelsResponse, CreateLabelsError, Credentials | Region | HttpClient.HttpClient>;
export type CreateNotificationSubscriptionError = InvalidArgumentException | ServiceUnavailableException | TooManySubscriptionsException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Configure Amazon WorkDocs to use Amazon SNS notifications. The endpoint receives a
 * confirmation message, and must confirm the subscription.
 *
 * For more information, see Setting up notifications for an IAM user or role in the Amazon WorkDocs Developer
 * Guide.
 */
export declare const createNotificationSubscription: API.OperationMethod<CreateNotificationSubscriptionRequest, CreateNotificationSubscriptionResponse, CreateNotificationSubscriptionError, Credentials | Region | HttpClient.HttpClient>;
export type CreateUserError = EntityAlreadyExistsException | FailedDependencyException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Creates a user in a Simple AD or Microsoft AD directory. The status of a newly
 * created user is "ACTIVE". New users can access Amazon WorkDocs.
 */
export declare const createUser: API.OperationMethod<CreateUserRequest, CreateUserResponse, CreateUserError, Credentials | Region | HttpClient.HttpClient>;
export type DeactivateUserError = EntityNotExistsException | FailedDependencyException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Deactivates the specified user, which revokes the user's access to Amazon
 * WorkDocs.
 */
export declare const deactivateUser: API.OperationMethod<DeactivateUserRequest, DeactivateUserResponse, DeactivateUserError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteCommentError = DocumentLockedForCommentsException | EntityNotExistsException | FailedDependencyException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Deletes the specified comment from the document version.
 */
export declare const deleteComment: API.OperationMethod<DeleteCommentRequest, DeleteCommentResponse, DeleteCommentError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteCustomMetadataError = EntityNotExistsException | FailedDependencyException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Deletes custom metadata from the specified resource.
 */
export declare const deleteCustomMetadata: API.OperationMethod<DeleteCustomMetadataRequest, DeleteCustomMetadataResponse, DeleteCustomMetadataError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteDocumentError = ConcurrentModificationException | ConflictingOperationException | EntityNotExistsException | FailedDependencyException | LimitExceededException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Permanently deletes the specified document and its associated metadata.
 */
export declare const deleteDocument: API.OperationMethod<DeleteDocumentRequest, DeleteDocumentResponse, DeleteDocumentError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteDocumentVersionError = ConcurrentModificationException | ConflictingOperationException | EntityNotExistsException | FailedDependencyException | InvalidOperationException | ProhibitedStateException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Deletes a specific version of a document.
 */
export declare const deleteDocumentVersion: API.OperationMethod<DeleteDocumentVersionRequest, DeleteDocumentVersionResponse, DeleteDocumentVersionError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteFolderError = ConcurrentModificationException | ConflictingOperationException | EntityNotExistsException | FailedDependencyException | LimitExceededException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Permanently deletes the specified folder and its contents.
 */
export declare const deleteFolder: API.OperationMethod<DeleteFolderRequest, DeleteFolderResponse, DeleteFolderError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteFolderContentsError = ConflictingOperationException | EntityNotExistsException | FailedDependencyException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Deletes the contents of the specified folder.
 */
export declare const deleteFolderContents: API.OperationMethod<DeleteFolderContentsRequest, DeleteFolderContentsResponse, DeleteFolderContentsError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteLabelsError = EntityNotExistsException | FailedDependencyException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Deletes the specified list of labels from a resource.
 */
export declare const deleteLabels: API.OperationMethod<DeleteLabelsRequest, DeleteLabelsResponse, DeleteLabelsError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteNotificationSubscriptionError = EntityNotExistsException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Deletes the specified subscription from the specified organization.
 */
export declare const deleteNotificationSubscription: API.OperationMethod<DeleteNotificationSubscriptionRequest, DeleteNotificationSubscriptionResponse, DeleteNotificationSubscriptionError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteUserError = EntityNotExistsException | FailedDependencyException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Deletes the specified user from a Simple AD or Microsoft AD directory.
 *
 * Deleting a user immediately and permanently deletes all content in that user's folder structure. Site retention policies do NOT apply to this type of deletion.
 */
export declare const deleteUser: API.OperationMethod<DeleteUserRequest, DeleteUserResponse, DeleteUserError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeActivitiesError = FailedDependencyException | InvalidArgumentException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Describes the user activities in a specified time period.
 */
export declare const describeActivities: API.OperationMethod<DescribeActivitiesRequest, DescribeActivitiesResponse, DescribeActivitiesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeActivitiesRequest) => stream.Stream<DescribeActivitiesResponse, DescribeActivitiesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeActivitiesRequest) => stream.Stream<Activity, DescribeActivitiesError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeCommentsError = EntityNotExistsException | FailedDependencyException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * List all the comments for the specified document version.
 */
export declare const describeComments: API.OperationMethod<DescribeCommentsRequest, DescribeCommentsResponse, DescribeCommentsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeCommentsRequest) => stream.Stream<DescribeCommentsResponse, DescribeCommentsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeCommentsRequest) => stream.Stream<Comment, DescribeCommentsError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeDocumentVersionsError = EntityNotExistsException | FailedDependencyException | InvalidArgumentException | InvalidPasswordException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Retrieves the document versions for the specified document.
 *
 * By default, only active versions are returned.
 */
export declare const describeDocumentVersions: API.OperationMethod<DescribeDocumentVersionsRequest, DescribeDocumentVersionsResponse, DescribeDocumentVersionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeDocumentVersionsRequest) => stream.Stream<DescribeDocumentVersionsResponse, DescribeDocumentVersionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeDocumentVersionsRequest) => stream.Stream<DocumentVersionMetadata, DescribeDocumentVersionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeFolderContentsError = EntityNotExistsException | FailedDependencyException | InvalidArgumentException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Describes the contents of the specified folder, including its documents and
 * subfolders.
 *
 * By default, Amazon WorkDocs returns the first 100 active document and folder
 * metadata items. If there are more results, the response includes a marker that you can
 * use to request the next set of results. You can also request initialized
 * documents.
 */
export declare const describeFolderContents: API.OperationMethod<DescribeFolderContentsRequest, DescribeFolderContentsResponse, DescribeFolderContentsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeFolderContentsRequest) => stream.Stream<DescribeFolderContentsResponse, DescribeFolderContentsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeFolderContentsRequest) => stream.Stream<unknown, DescribeFolderContentsError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeGroupsError = FailedDependencyException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Describes the groups specified by the query. Groups are defined by the underlying
 * Active Directory.
 */
export declare const describeGroups: API.OperationMethod<DescribeGroupsRequest, DescribeGroupsResponse, DescribeGroupsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeGroupsRequest) => stream.Stream<DescribeGroupsResponse, DescribeGroupsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeGroupsRequest) => stream.Stream<GroupMetadata, DescribeGroupsError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeNotificationSubscriptionsError = EntityNotExistsException | ServiceUnavailableException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Lists the specified notification subscriptions.
 */
export declare const describeNotificationSubscriptions: API.OperationMethod<DescribeNotificationSubscriptionsRequest, DescribeNotificationSubscriptionsResponse, DescribeNotificationSubscriptionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeNotificationSubscriptionsRequest) => stream.Stream<DescribeNotificationSubscriptionsResponse, DescribeNotificationSubscriptionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeNotificationSubscriptionsRequest) => stream.Stream<Subscription, DescribeNotificationSubscriptionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeResourcePermissionsError = FailedDependencyException | InvalidArgumentException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Describes the permissions of a specified resource.
 */
export declare const describeResourcePermissions: API.OperationMethod<DescribeResourcePermissionsRequest, DescribeResourcePermissionsResponse, DescribeResourcePermissionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeResourcePermissionsRequest) => stream.Stream<DescribeResourcePermissionsResponse, DescribeResourcePermissionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeResourcePermissionsRequest) => stream.Stream<Principal, DescribeResourcePermissionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeRootFoldersError = FailedDependencyException | InvalidArgumentException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Describes the current user's special folders; the `RootFolder` and the
 * `RecycleBin`. `RootFolder` is the root of user's files and
 * folders and `RecycleBin` is the root of recycled items. This is not a valid
 * action for SigV4 (administrative API) clients.
 *
 * This action requires an authentication token. To get an authentication token,
 * register an application with Amazon WorkDocs. For more information, see Authentication and Access
 * Control for User Applications in the
 * Amazon
 * WorkDocs Developer Guide.
 */
export declare const describeRootFolders: API.OperationMethod<DescribeRootFoldersRequest, DescribeRootFoldersResponse, DescribeRootFoldersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeRootFoldersRequest) => stream.Stream<DescribeRootFoldersResponse, DescribeRootFoldersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeRootFoldersRequest) => stream.Stream<FolderMetadata, DescribeRootFoldersError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeUsersError = EntityNotExistsException | FailedDependencyException | InvalidArgumentException | RequestedEntityTooLargeException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Describes the specified users. You can describe all users or filter the results
 * (for example, by status or organization).
 *
 * By default, Amazon WorkDocs returns the first 24 active or pending users. If there
 * are more results, the response includes a marker that you can use to request the next
 * set of results.
 */
export declare const describeUsers: API.OperationMethod<DescribeUsersRequest, DescribeUsersResponse, DescribeUsersError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeUsersRequest) => stream.Stream<DescribeUsersResponse, DescribeUsersError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeUsersRequest) => stream.Stream<User, DescribeUsersError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetCurrentUserError = EntityNotExistsException | FailedDependencyException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Retrieves details of the current user for whom the authentication token was
 * generated. This is not a valid action for SigV4 (administrative API) clients.
 *
 * This action requires an authentication token. To get an authentication token,
 * register an application with Amazon WorkDocs. For more information, see Authentication and Access
 * Control for User Applications in the
 * Amazon
 * WorkDocs Developer Guide.
 */
export declare const getCurrentUser: API.OperationMethod<GetCurrentUserRequest, GetCurrentUserResponse, GetCurrentUserError, Credentials | Region | HttpClient.HttpClient>;
export type GetDocumentError = EntityNotExistsException | FailedDependencyException | InvalidArgumentException | InvalidPasswordException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Retrieves details of a document.
 */
export declare const getDocument: API.OperationMethod<GetDocumentRequest, GetDocumentResponse, GetDocumentError, Credentials | Region | HttpClient.HttpClient>;
export type GetDocumentPathError = EntityNotExistsException | FailedDependencyException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Retrieves the path information (the hierarchy from the root folder) for the
 * requested document.
 *
 * By default, Amazon WorkDocs returns a maximum of 100 levels upwards from the
 * requested document and only includes the IDs of the parent folders in the path. You can
 * limit the maximum number of levels. You can also request the names of the parent
 * folders.
 */
export declare const getDocumentPath: API.OperationMethod<GetDocumentPathRequest, GetDocumentPathResponse, GetDocumentPathError, Credentials | Region | HttpClient.HttpClient>;
export type GetDocumentVersionError = EntityNotExistsException | FailedDependencyException | InvalidPasswordException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Retrieves version metadata for the specified document.
 */
export declare const getDocumentVersion: API.OperationMethod<GetDocumentVersionRequest, GetDocumentVersionResponse, GetDocumentVersionError, Credentials | Region | HttpClient.HttpClient>;
export type GetFolderError = EntityNotExistsException | FailedDependencyException | InvalidArgumentException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Retrieves the metadata of the specified folder.
 */
export declare const getFolder: API.OperationMethod<GetFolderRequest, GetFolderResponse, GetFolderError, Credentials | Region | HttpClient.HttpClient>;
export type GetFolderPathError = EntityNotExistsException | FailedDependencyException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Retrieves the path information (the hierarchy from the root folder) for the
 * specified folder.
 *
 * By default, Amazon WorkDocs returns a maximum of 100 levels upwards from the
 * requested folder and only includes the IDs of the parent folders in the path. You can
 * limit the maximum number of levels. You can also request the parent folder
 * names.
 */
export declare const getFolderPath: API.OperationMethod<GetFolderPathRequest, GetFolderPathResponse, GetFolderPathError, Credentials | Region | HttpClient.HttpClient>;
export type GetResourcesError = FailedDependencyException | InvalidArgumentException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Retrieves a collection of resources, including folders and documents. The only
 * `CollectionType` supported is `SHARED_WITH_ME`.
 */
export declare const getResources: API.OperationMethod<GetResourcesRequest, GetResourcesResponse, GetResourcesError, Credentials | Region | HttpClient.HttpClient>;
export type InitiateDocumentVersionUploadError = DraftUploadOutOfSyncException | EntityAlreadyExistsException | EntityNotExistsException | FailedDependencyException | InvalidArgumentException | InvalidPasswordException | LimitExceededException | ProhibitedStateException | ResourceAlreadyCheckedOutException | ServiceUnavailableException | StorageLimitExceededException | StorageLimitWillExceedException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Creates a new document object and version object.
 *
 * The client specifies the parent folder ID and name of the document to upload. The
 * ID is optionally specified when creating a new version of an existing document. This is
 * the first step to upload a document. Next, upload the document to the URL returned from
 * the call, and then call UpdateDocumentVersion.
 *
 * To cancel the document upload, call AbortDocumentVersionUpload.
 */
export declare const initiateDocumentVersionUpload: API.OperationMethod<InitiateDocumentVersionUploadRequest, InitiateDocumentVersionUploadResponse, InitiateDocumentVersionUploadError, Credentials | Region | HttpClient.HttpClient>;
export type RemoveAllResourcePermissionsError = FailedDependencyException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Removes all the permissions from the specified resource.
 */
export declare const removeAllResourcePermissions: API.OperationMethod<RemoveAllResourcePermissionsRequest, RemoveAllResourcePermissionsResponse, RemoveAllResourcePermissionsError, Credentials | Region | HttpClient.HttpClient>;
export type RemoveResourcePermissionError = FailedDependencyException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Removes the permission for the specified principal from the specified
 * resource.
 */
export declare const removeResourcePermission: API.OperationMethod<RemoveResourcePermissionRequest, RemoveResourcePermissionResponse, RemoveResourcePermissionError, Credentials | Region | HttpClient.HttpClient>;
export type RestoreDocumentVersionsError = ConcurrentModificationException | ConflictingOperationException | EntityNotExistsException | FailedDependencyException | InvalidOperationException | ProhibitedStateException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Recovers a deleted version of an Amazon WorkDocs document.
 */
export declare const restoreDocumentVersions: API.OperationMethod<RestoreDocumentVersionsRequest, RestoreDocumentVersionsResponse, RestoreDocumentVersionsError, Credentials | Region | HttpClient.HttpClient>;
export type SearchResourcesError = InvalidArgumentException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Searches metadata and the content of folders, documents, document versions, and comments.
 */
export declare const searchResources: API.OperationMethod<SearchResourcesRequest, SearchResourcesResponse, SearchResourcesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: SearchResourcesRequest) => stream.Stream<SearchResourcesResponse, SearchResourcesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: SearchResourcesRequest) => stream.Stream<ResponseItem, SearchResourcesError, Credentials | Region | HttpClient.HttpClient>;
};
export type UpdateDocumentError = ConcurrentModificationException | ConflictingOperationException | EntityAlreadyExistsException | EntityNotExistsException | FailedDependencyException | LimitExceededException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Updates the specified attributes of a document. The user must have access to both
 * the document and its parent folder, if applicable.
 */
export declare const updateDocument: API.OperationMethod<UpdateDocumentRequest, UpdateDocumentResponse, UpdateDocumentError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateDocumentVersionError = ConcurrentModificationException | EntityNotExistsException | FailedDependencyException | InvalidOperationException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Changes the status of the document version to ACTIVE.
 *
 * Amazon WorkDocs also sets its document container to ACTIVE. This is the last step
 * in a document upload, after the client uploads the document to an S3-presigned URL
 * returned by InitiateDocumentVersionUpload.
 */
export declare const updateDocumentVersion: API.OperationMethod<UpdateDocumentVersionRequest, UpdateDocumentVersionResponse, UpdateDocumentVersionError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateFolderError = ConcurrentModificationException | ConflictingOperationException | EntityAlreadyExistsException | EntityNotExistsException | FailedDependencyException | LimitExceededException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Updates the specified attributes of the specified folder. The user must have access
 * to both the folder and its parent folder, if applicable.
 */
export declare const updateFolder: API.OperationMethod<UpdateFolderRequest, UpdateFolderResponse, UpdateFolderError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateUserError = DeactivatingLastSystemUserException | EntityNotExistsException | FailedDependencyException | IllegalUserStateException | InvalidArgumentException | ProhibitedStateException | ServiceUnavailableException | UnauthorizedOperationException | UnauthorizedResourceAccessException | CommonErrors;
/**
 * Updates the specified attributes of the specified user, and grants or revokes
 * administrative privileges to the Amazon WorkDocs site.
 */
export declare const updateUser: API.OperationMethod<UpdateUserRequest, UpdateUserResponse, UpdateUserError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=workdocs.d.ts.map