Class API

API

Date

2/1/2024 - 4:46:43 PM

Export

Constructors

constructor

Properties

_v3 apiClient config crypto

Methods

v3

Constructors

constructor

Properties

Private Readonly _v3

_v3: {
    auth: {
        info: AuthInfo;
    };
    chat: {
        conversations: ChatConversations;
        conversationsCreate: ChatConversationsCreate;
        conversationsDelete: ChatConversationsDelete;
        conversationsLeave: ChatConversationsLeave;
        conversationsName: {
            edit: ChatConversationsNameEdit;
        };
        conversationsOnline: ChatConversationsOnline;
        conversationsParticipants: {
            add: ChatConversationsParticipantsAdd;
            remove: ChatConversationsParticipantsRemove;
        };
        conversationsRead: ChatConversationsRead;
        conversationsUnread: ChatConversationsUnread;
        delete: ChatDelete;
        edit: ChatEdit;
        lastFocus: ChatLastFocus;
        lastFocusUpdate: ChatLastFocusUpdate;
        message: {
            embed: {
                disable: ChatMessageEmbedDisable;
            };
        };
        messages: ChatMessages;
        send: ChatSend;
        typing: ChatTyping;
        unread: ChatUnread;
    };
    confirmationSend: ConfirmationSend;
    contacts: {
        all: Contacts;
        blocked: ContactsBlocked;
        blockedAdd: ContactsBlockedAdd;
        blockedDelete: ContactsBlockedDelete;
        delete: ContactsDelete;
        requestsAccept: ContactsRequestsAccept;
        requestsDeny: ContactsRequestsDeny;
        requestsIn: ContactsRequestsIn;
        requestsInCount: ContactsRequestsInCount;
        requestsOut: ContactsRequestsOut;
        requestsOutDelete: ContactsRequestsOutDelete;
        requestsSend: ContactsRequestsSend;
    };
    dir: {
        color: DirColor;
        content: DirContent;
        create: DirCreate;
        delete: {
            permanent: DirDeletePermanent;
        };
        download: DirDownload;
        exists: DirExists;
        link: {
            add: DirLinkAdd;
            content: DirLinkContent;
            edit: DirLinkEdit;
            info: DirLinkInfo;
            remove: DirLinkRemove;
            status: DirLinkStatus;
        };
        linked: DirLinked;
        move: DirMove;
        present: DirPresent;
        rename: DirRename;
        restore: DirRestore;
        shared: DirShared;
        size: DirSize;
        sizeLink: DirSizeLink;
        trash: DirTrash;
        tree: DirTree;
    };
    file: {
        delete: {
            permanent: FileDeletePermanent;
        };
        download: {
            chunk: {
                buffer: FileDownloadChunkBuffer;
                local: FileDownloadChunkLocal;
                stream: FileDownloadChunkStream;
            };
        };
        exists: FileExists;
        link: {
            edit: FileLinkEdit;
            info: FileLinkInfo;
            password: FileLinkPassword;
            status: FileLinkStatus;
        };
        move: FileMove;
        rename: FileRename;
        restore: FileRestore;
        trash: FileTrash;
        upload: {
            chunk: {
                buffer: FileUploadChunkBuffer;
            };
        };
        version: {
            restore: FileVersionRestore;
        };
        versions: FileVersions;
    };
    health: Health;
    item: {
        favorite: ItemFavorite;
        linked: ItemLinked;
        linkedRename: ItemLinkedRename;
        share: ItemShare;
        shared: ItemShared;
        sharedIn: {
            remove: ItemSharedInRemove;
        };
        sharedOut: {
            remove: ItemSharedOutRemove;
        };
        sharedRename: ItemSharedRename;
    };
    login: Login;
    notes: {
        all: Notes;
        archive: NotesArchive;
        content: NotesContent;
        contentEdit: NotesContentEdit;
        create: NotesCreate;
        delete: NotesDelete;
        favorite: NotesFavorite;
        history: NotesHistory;
        historyRestore: NotesHistoryRestore;
        participantsAdd: NotesParticipantsAdd;
        participantsPermissions: NotesParticipantsPermissions;
        participantsRemove: NotesParticipantsRemove;
        pinned: NotesPinned;
        restore: NotesRestore;
        tag: NotesTag;
        tags: NotesTags;
        tagsCreate: NotesTagsCreate;
        tagsDelete: NotesTagsDelete;
        tagsFavorite: NotesTagsFavorite;
        tagsRename: NotesTagsRename;
        titleEdit: NoteTitleEdit;
        trash: NotesTrash;
        typeChange: NotesTypeChange;
        untag: NotesUntag;
    };
    register: Register;
    shared: {
        in: SharedIn;
        out: SharedOut;
    };
    trash: {
        empty: TrashEmpty;
    };
    upload: {
        done: UploadDone;
    };
    user: {
        account: UserAccount;
        affiliate: {
            payout: UserAffiliatePayout;
        };
        appearOffline: UserAppearOffline;
        avatar: UserAvatar;
        baseFolder: UserBaseFolder;
        delete: UserDelete;
        deleteAll: UserDeleteAll;
        deleteVersions: UserDeleteVersions;
        didExportMasterKeys: UserDidExportMasterKeys;
        event: UserEvent;
        events: UserEvents;
        gdpr: UserGDPR;
        info: UserInfo;
        invoice: UserInvoice;
        keyPair: {
            info: UserKeyPairInfo;
            set: UserKeyPairSet;
            update: UserKeyPairUpdate;
        };
        lastActive: {
            desktop: UserLastActiveDesktop;
        };
        lock: UserLock;
        loginAlerts: UserLoginAlerts;
        masterKeys: UserMasterKeys;
        nickname: UserNickname;
        password: {
            forgot: UserPasswordForgot;
            forgotReset: UserPasswordForgotReset;
        };
        personal: {
            update: UserPersonalUpdate;
        };
        profile: UserProfile;
        publicKey: UserPublicKey;
        settings: UserSettings;
        settingsEmail: {
            change: UserSettingsEmailChange;
        };
        settingsPassword: {
            change: UserSettingsPasswordChange;
        };
        sub: {
            cancel: UserSubCancel;
            create: UserSubCreate;
        };
        twoFactorAuthentication: {
            disable: User2FADisable;
            enable: User2FAEnable;
        };
        versioning: UserVersioning;
    };
}

Type declaration

Private Readonly apiClient

apiClient: APIClient

Private Readonly config

config: APIConfig

Private Readonly crypto

crypto: Crypto

Methods

v3

  • v3(): {
        auth: (() => {
            info: ((...params) => Promise<AuthInfoResponse>);
        });
        chat: (() => {
            conversations: ((...params) => Promise<ChatConversation[]>);
            conversationsCreate: ((...params) => Promise<void>);
            conversationsDelete: ((...params) => Promise<void>);
            conversationsLeave: ((...params) => Promise<void>);
            conversationsName: (() => {
                edit: ((...params) => Promise<void>);
            });
            conversationsOnline: ((...params) => Promise<ChatConversationsOnlineResponse>);
            conversationsParticipants: (() => {
                add: ((...params) => Promise<void>);
                remove: ((...params) => Promise<void>);
            });
            conversationsRead: ((...params) => Promise<void>);
            conversationsUnread: ((...params) => Promise<ChatConversationsUnreadResponse>);
            delete: ((...params) => Promise<void>);
            edit: ((...params) => Promise<void>);
            lastFocus: ((...params) => Promise<ChatLastFocusValues[]>);
            lastFocusUpdate: ((...params) => Promise<void>);
            message: (() => {
                embed: (() => {
                    disable: ((...params) => Promise<void>);
                });
            });
            messages: ((...params) => Promise<ChatMessage[]>);
            send: ((...params) => Promise<void>);
            typing: ((...params) => Promise<void>);
            unread: ((...params) => Promise<ChatUnreadResponse>);
        });
        confirmationSend: ((...params) => Promise<void>);
        contacts: (() => {
            all: ((...params) => Promise<ContactsResponse>);
            blocked: ((...params) => Promise<ContactsBlockedResponse>);
            blockedAdd: ((...params) => Promise<void>);
            blockedDelete: ((...params) => Promise<void>);
            delete: ((...params) => Promise<void>);
            requestsAccept: ((...params) => Promise<void>);
            requestsDeny: ((...params) => Promise<void>);
            requestsIn: ((...params) => Promise<ContactsRequestsInResponse>);
            requestsInCount: ((...params) => Promise<number>);
            requestsOut: ((...params) => Promise<ContactsRequestsOutResponse>);
            requestsOutDelete: ((...params) => Promise<void>);
            requestsSend: ((...params) => Promise<void>);
        });
        dir: (() => {
            color: ((...params) => Promise<void>);
            content: ((...params) => Promise<DirContentResponse>);
            create: ((...params) => Promise<DirCreateResponse>);
            delete: (() => {
                permanent: ((...params) => Promise<void>);
            });
            download: ((...params) => Promise<DirDownloadResponse>);
            exists: ((...params) => Promise<DirExistsResponse>);
            link: (() => {
                add: ((...params) => Promise<void>);
                content: ((...params) => Promise<DirLinkContentResponse>);
                edit: ((...params) => Promise<void>);
                info: ((...params) => Promise<DirLinkInfoResponse>);
                remove: ((...params) => Promise<void>);
                status: ((...params) => Promise<DirLinkStatusResponse>);
            });
            linked: ((...params) => Promise<DirLinkedResponse>);
            move: ((...params) => Promise<void>);
            present: ((...params) => Promise<DirPresentResponse>);
            rename: ((...params) => Promise<void>);
            restore: ((...params) => Promise<void>);
            shared: ((...params) => Promise<DirSharedResponse>);
            size: ((...params) => Promise<DirSizeResponse>);
            sizeLink: ((...params) => Promise<DirSizeLinkResponse>);
            trash: ((...params) => Promise<void>);
            tree: ((...params) => Promise<DirTreeResponse>);
        });
        file: (() => {
            delete: (() => {
                permanent: ((...params) => Promise<void>);
            });
            download: (() => {
                chunk: (() => {
                    buffer: ((...params) => Promise<Buffer>);
                    local: ((...params) => Promise<void>);
                    stream: ((...params) => Promise<ReadStream | ReadableStream<any>>);
                });
            });
            exists: ((...params) => Promise<FileExistsResponse>);
            link: (() => {
                edit: ((...params) => Promise<void>);
                info: ((...params) => Promise<FileLinkInfoResponse>);
                password: ((...params) => Promise<FileLinkPasswordResponse>);
                status: ((...params) => Promise<FileLinkStatusResponse>);
            });
            move: ((...params) => Promise<void>);
            rename: ((...params) => Promise<void>);
            restore: ((...params) => Promise<void>);
            trash: ((...params) => Promise<void>);
            upload: (() => {
                chunk: (() => {
                    buffer: ((...params) => Promise<UploadChunkResponse>);
                });
            });
            version: (() => {
                restore: ((...params) => Promise<void>);
            });
            versions: ((...params) => Promise<FileVersionsResponse>);
        });
        health: (() => Promise<"OK">);
        item: (() => {
            favorite: ((...params) => Promise<void>);
            linked: ((...params) => Promise<ItemLinkedResponse>);
            linkedRename: ((...params) => Promise<void>);
            share: ((...params) => Promise<void>);
            shared: ((...params) => Promise<ItemSharedResponse>);
            sharedIn: (() => {
                remove: ((...params) => Promise<void>);
            });
            sharedOut: (() => {
                remove: ((...params) => Promise<void>);
            });
            sharedRename: ((...params) => Promise<void>);
        });
        login: ((...params) => Promise<LoginResponse>);
        notes: (() => {
            all: ((...params) => Promise<NotesResponse>);
            archive: ((...params) => Promise<void>);
            content: ((...params) => Promise<NoteContent>);
            contentEdit: ((...params) => Promise<void>);
            create: ((...params) => Promise<void>);
            delete: ((...params) => Promise<void>);
            favorite: ((...params) => Promise<void>);
            history: ((...params) => Promise<NotesHistoryResponse>);
            historyRestore: ((...params) => Promise<void>);
            participantsAdd: ((...params) => Promise<void>);
            participantsPermissions: ((...params) => Promise<void>);
            participantsRemove: ((...params) => Promise<void>);
            pinned: ((...params) => Promise<void>);
            restore: ((...params) => Promise<void>);
            tag: ((...params) => Promise<void>);
            tags: ((...params) => Promise<NotesTagsResponse>);
            tagsCreate: ((...params) => Promise<NotesTagsCreateResponse>);
            tagsDelete: ((...params) => Promise<void>);
            tagsFavorite: ((...params) => Promise<void>);
            tagsRename: ((...params) => Promise<void>);
            titleEdit: ((...params) => Promise<void>);
            trash: ((...params) => Promise<void>);
            typeChange: ((...params) => Promise<void>);
            untag: ((...params) => Promise<void>);
        });
        register: ((...params) => Promise<void>);
        shared: (() => {
            in: ((...params) => Promise<SharedInResponse>);
            out: ((...params) => Promise<SharedOutResponse>);
        });
        trash: (() => {
            empty: ((...params) => Promise<void>);
        });
        upload: (() => {
            done: ((...params) => Promise<UploadDoneResponse>);
        });
        user: (() => {
            account: ((...params) => Promise<UserAccountResponse>);
            affiliate: (() => {
                payout: ((...params) => Promise<void>);
            });
            appearOffline: ((...params) => Promise<void>);
            avatar: ((...params) => Promise<void>);
            baseFolder: ((...params) => Promise<UserBaseFolderResponse>);
            delete: ((...params) => Promise<void>);
            deleteAll: ((...params) => Promise<void>);
            deleteVersions: ((...params) => Promise<void>);
            didExportMasterKeys: ((...params) => Promise<void>);
            event: ((...params) => Promise<UserEvent>);
            events: ((...params) => Promise<UserEvent[]>);
            gdpr: ((...params) => Promise<UserGDPRResponse>);
            info: ((...params) => Promise<UserInfoResponse>);
            invoice: ((...params) => Promise<string>);
            keyPair: (() => {
                info: ((...params) => Promise<UserKeyPairInfoResponse>);
                set: ((...params) => Promise<void>);
                update: ((...params) => Promise<void>);
            });
            lastActive: (() => {
                desktop: ((...params) => Promise<void>);
            });
            lock: ((...params) => Promise<UserLockResponse>);
            loginAlerts: ((...params) => Promise<void>);
            masterKeys: ((...params) => Promise<UserMasterKeysResponse>);
            nickname: ((...params) => Promise<void>);
            password: (() => {
                forgot: ((...params) => Promise<void>);
                forgotReset: ((...params) => Promise<void>);
            });
            personal: (() => {
                change: ((...params) => Promise<void>);
            });
            profile: ((...params) => Promise<UserProfileResponse>);
            publicKey: ((...params) => Promise<UserPublicKeyResponse>);
            settings: ((...params) => Promise<UserSettingsResponse>);
            settingsEmail: (() => {
                change: ((...params) => Promise<void>);
            });
            settingsPassword: (() => {
                change: ((...params) => Promise<UserSettingsPasswordChangeResponse>);
            });
            sub: (() => {
                cancel: ((...params) => Promise<void>);
                create: ((...params) => Promise<UserSubCreateResponse>);
            });
            twoFactorAuthentication: (() => {
                disable: ((...params) => Promise<void>);
                enable: ((...params) => Promise<User2FAEnableResponse>);
            });
            versioning: ((...params) => Promise<void>);
        });
    }

  • Returns {
        auth: (() => {
            info: ((...params) => Promise<AuthInfoResponse>);
        });
        chat: (() => {
            conversations: ((...params) => Promise<ChatConversation[]>);
            conversationsCreate: ((...params) => Promise<void>);
            conversationsDelete: ((...params) => Promise<void>);
            conversationsLeave: ((...params) => Promise<void>);
            conversationsName: (() => {
                edit: ((...params) => Promise<void>);
            });
            conversationsOnline: ((...params) => Promise<ChatConversationsOnlineResponse>);
            conversationsParticipants: (() => {
                add: ((...params) => Promise<void>);
                remove: ((...params) => Promise<void>);
            });
            conversationsRead: ((...params) => Promise<void>);
            conversationsUnread: ((...params) => Promise<ChatConversationsUnreadResponse>);
            delete: ((...params) => Promise<void>);
            edit: ((...params) => Promise<void>);
            lastFocus: ((...params) => Promise<ChatLastFocusValues[]>);
            lastFocusUpdate: ((...params) => Promise<void>);
            message: (() => {
                embed: (() => {
                    disable: ((...params) => Promise<void>);
                });
            });
            messages: ((...params) => Promise<ChatMessage[]>);
            send: ((...params) => Promise<void>);
            typing: ((...params) => Promise<void>);
            unread: ((...params) => Promise<ChatUnreadResponse>);
        });
        confirmationSend: ((...params) => Promise<void>);
        contacts: (() => {
            all: ((...params) => Promise<ContactsResponse>);
            blocked: ((...params) => Promise<ContactsBlockedResponse>);
            blockedAdd: ((...params) => Promise<void>);
            blockedDelete: ((...params) => Promise<void>);
            delete: ((...params) => Promise<void>);
            requestsAccept: ((...params) => Promise<void>);
            requestsDeny: ((...params) => Promise<void>);
            requestsIn: ((...params) => Promise<ContactsRequestsInResponse>);
            requestsInCount: ((...params) => Promise<number>);
            requestsOut: ((...params) => Promise<ContactsRequestsOutResponse>);
            requestsOutDelete: ((...params) => Promise<void>);
            requestsSend: ((...params) => Promise<void>);
        });
        dir: (() => {
            color: ((...params) => Promise<void>);
            content: ((...params) => Promise<DirContentResponse>);
            create: ((...params) => Promise<DirCreateResponse>);
            delete: (() => {
                permanent: ((...params) => Promise<void>);
            });
            download: ((...params) => Promise<DirDownloadResponse>);
            exists: ((...params) => Promise<DirExistsResponse>);
            link: (() => {
                add: ((...params) => Promise<void>);
                content: ((...params) => Promise<DirLinkContentResponse>);
                edit: ((...params) => Promise<void>);
                info: ((...params) => Promise<DirLinkInfoResponse>);
                remove: ((...params) => Promise<void>);
                status: ((...params) => Promise<DirLinkStatusResponse>);
            });
            linked: ((...params) => Promise<DirLinkedResponse>);
            move: ((...params) => Promise<void>);
            present: ((...params) => Promise<DirPresentResponse>);
            rename: ((...params) => Promise<void>);
            restore: ((...params) => Promise<void>);
            shared: ((...params) => Promise<DirSharedResponse>);
            size: ((...params) => Promise<DirSizeResponse>);
            sizeLink: ((...params) => Promise<DirSizeLinkResponse>);
            trash: ((...params) => Promise<void>);
            tree: ((...params) => Promise<DirTreeResponse>);
        });
        file: (() => {
            delete: (() => {
                permanent: ((...params) => Promise<void>);
            });
            download: (() => {
                chunk: (() => {
                    buffer: ((...params) => Promise<Buffer>);
                    local: ((...params) => Promise<void>);
                    stream: ((...params) => Promise<ReadStream | ReadableStream<any>>);
                });
            });
            exists: ((...params) => Promise<FileExistsResponse>);
            link: (() => {
                edit: ((...params) => Promise<void>);
                info: ((...params) => Promise<FileLinkInfoResponse>);
                password: ((...params) => Promise<FileLinkPasswordResponse>);
                status: ((...params) => Promise<FileLinkStatusResponse>);
            });
            move: ((...params) => Promise<void>);
            rename: ((...params) => Promise<void>);
            restore: ((...params) => Promise<void>);
            trash: ((...params) => Promise<void>);
            upload: (() => {
                chunk: (() => {
                    buffer: ((...params) => Promise<UploadChunkResponse>);
                });
            });
            version: (() => {
                restore: ((...params) => Promise<void>);
            });
            versions: ((...params) => Promise<FileVersionsResponse>);
        });
        health: (() => Promise<"OK">);
        item: (() => {
            favorite: ((...params) => Promise<void>);
            linked: ((...params) => Promise<ItemLinkedResponse>);
            linkedRename: ((...params) => Promise<void>);
            share: ((...params) => Promise<void>);
            shared: ((...params) => Promise<ItemSharedResponse>);
            sharedIn: (() => {
                remove: ((...params) => Promise<void>);
            });
            sharedOut: (() => {
                remove: ((...params) => Promise<void>);
            });
            sharedRename: ((...params) => Promise<void>);
        });
        login: ((...params) => Promise<LoginResponse>);
        notes: (() => {
            all: ((...params) => Promise<NotesResponse>);
            archive: ((...params) => Promise<void>);
            content: ((...params) => Promise<NoteContent>);
            contentEdit: ((...params) => Promise<void>);
            create: ((...params) => Promise<void>);
            delete: ((...params) => Promise<void>);
            favorite: ((...params) => Promise<void>);
            history: ((...params) => Promise<NotesHistoryResponse>);
            historyRestore: ((...params) => Promise<void>);
            participantsAdd: ((...params) => Promise<void>);
            participantsPermissions: ((...params) => Promise<void>);
            participantsRemove: ((...params) => Promise<void>);
            pinned: ((...params) => Promise<void>);
            restore: ((...params) => Promise<void>);
            tag: ((...params) => Promise<void>);
            tags: ((...params) => Promise<NotesTagsResponse>);
            tagsCreate: ((...params) => Promise<NotesTagsCreateResponse>);
            tagsDelete: ((...params) => Promise<void>);
            tagsFavorite: ((...params) => Promise<void>);
            tagsRename: ((...params) => Promise<void>);
            titleEdit: ((...params) => Promise<void>);
            trash: ((...params) => Promise<void>);
            typeChange: ((...params) => Promise<void>);
            untag: ((...params) => Promise<void>);
        });
        register: ((...params) => Promise<void>);
        shared: (() => {
            in: ((...params) => Promise<SharedInResponse>);
            out: ((...params) => Promise<SharedOutResponse>);
        });
        trash: (() => {
            empty: ((...params) => Promise<void>);
        });
        upload: (() => {
            done: ((...params) => Promise<UploadDoneResponse>);
        });
        user: (() => {
            account: ((...params) => Promise<UserAccountResponse>);
            affiliate: (() => {
                payout: ((...params) => Promise<void>);
            });
            appearOffline: ((...params) => Promise<void>);
            avatar: ((...params) => Promise<void>);
            baseFolder: ((...params) => Promise<UserBaseFolderResponse>);
            delete: ((...params) => Promise<void>);
            deleteAll: ((...params) => Promise<void>);
            deleteVersions: ((...params) => Promise<void>);
            didExportMasterKeys: ((...params) => Promise<void>);
            event: ((...params) => Promise<UserEvent>);
            events: ((...params) => Promise<UserEvent[]>);
            gdpr: ((...params) => Promise<UserGDPRResponse>);
            info: ((...params) => Promise<UserInfoResponse>);
            invoice: ((...params) => Promise<string>);
            keyPair: (() => {
                info: ((...params) => Promise<UserKeyPairInfoResponse>);
                set: ((...params) => Promise<void>);
                update: ((...params) => Promise<void>);
            });
            lastActive: (() => {
                desktop: ((...params) => Promise<void>);
            });
            lock: ((...params) => Promise<UserLockResponse>);
            loginAlerts: ((...params) => Promise<void>);
            masterKeys: ((...params) => Promise<UserMasterKeysResponse>);
            nickname: ((...params) => Promise<void>);
            password: (() => {
                forgot: ((...params) => Promise<void>);
                forgotReset: ((...params) => Promise<void>);
            });
            personal: (() => {
                change: ((...params) => Promise<void>);
            });
            profile: ((...params) => Promise<UserProfileResponse>);
            publicKey: ((...params) => Promise<UserPublicKeyResponse>);
            settings: ((...params) => Promise<UserSettingsResponse>);
            settingsEmail: (() => {
                change: ((...params) => Promise<void>);
            });
            settingsPassword: (() => {
                change: ((...params) => Promise<UserSettingsPasswordChangeResponse>);
            });
            sub: (() => {
                cancel: ((...params) => Promise<void>);
                create: ((...params) => Promise<UserSubCreateResponse>);
            });
            twoFactorAuthentication: (() => {
                disable: ((...params) => Promise<void>);
                enable: ((...params) => Promise<User2FAEnableResponse>);
            });
            versioning: ((...params) => Promise<void>);
        });
    }

    • auth: (() => {
          info: ((...params) => Promise<AuthInfoResponse>);
      })
    • chat: (() => {
          conversations: ((...params) => Promise<ChatConversation[]>);
          conversationsCreate: ((...params) => Promise<void>);
          conversationsDelete: ((...params) => Promise<void>);
          conversationsLeave: ((...params) => Promise<void>);
          conversationsName: (() => {
              edit: ((...params) => Promise<void>);
          });
          conversationsOnline: ((...params) => Promise<ChatConversationsOnlineResponse>);
          conversationsParticipants: (() => {
              add: ((...params) => Promise<void>);
              remove: ((...params) => Promise<void>);
          });
          conversationsRead: ((...params) => Promise<void>);
          conversationsUnread: ((...params) => Promise<ChatConversationsUnreadResponse>);
          delete: ((...params) => Promise<void>);
          edit: ((...params) => Promise<void>);
          lastFocus: ((...params) => Promise<ChatLastFocusValues[]>);
          lastFocusUpdate: ((...params) => Promise<void>);
          message: (() => {
              embed: (() => {
                  disable: ((...params) => Promise<void>);
              });
          });
          messages: ((...params) => Promise<ChatMessage[]>);
          send: ((...params) => Promise<void>);
          typing: ((...params) => Promise<void>);
          unread: ((...params) => Promise<ChatUnreadResponse>);
      })
        • (): {
              conversations: ((...params) => Promise<ChatConversation[]>);
              conversationsCreate: ((...params) => Promise<void>);
              conversationsDelete: ((...params) => Promise<void>);
              conversationsLeave: ((...params) => Promise<void>);
              conversationsName: (() => {
                  edit: ((...params) => Promise<void>);
              });
              conversationsOnline: ((...params) => Promise<ChatConversationsOnlineResponse>);
              conversationsParticipants: (() => {
                  add: ((...params) => Promise<void>);
                  remove: ((...params) => Promise<void>);
              });
              conversationsRead: ((...params) => Promise<void>);
              conversationsUnread: ((...params) => Promise<ChatConversationsUnreadResponse>);
              delete: ((...params) => Promise<void>);
              edit: ((...params) => Promise<void>);
              lastFocus: ((...params) => Promise<ChatLastFocusValues[]>);
              lastFocusUpdate: ((...params) => Promise<void>);
              message: (() => {
                  embed: (() => {
                      disable: ((...params) => Promise<void>);
                  });
              });
              messages: ((...params) => Promise<ChatMessage[]>);
              send: ((...params) => Promise<void>);
              typing: ((...params) => Promise<void>);
              unread: ((...params) => Promise<ChatUnreadResponse>);
          }

        • Returns {
              conversations: ((...params) => Promise<ChatConversation[]>);
              conversationsCreate: ((...params) => Promise<void>);
              conversationsDelete: ((...params) => Promise<void>);
              conversationsLeave: ((...params) => Promise<void>);
              conversationsName: (() => {
                  edit: ((...params) => Promise<void>);
              });
              conversationsOnline: ((...params) => Promise<ChatConversationsOnlineResponse>);
              conversationsParticipants: (() => {
                  add: ((...params) => Promise<void>);
                  remove: ((...params) => Promise<void>);
              });
              conversationsRead: ((...params) => Promise<void>);
              conversationsUnread: ((...params) => Promise<ChatConversationsUnreadResponse>);
              delete: ((...params) => Promise<void>);
              edit: ((...params) => Promise<void>);
              lastFocus: ((...params) => Promise<ChatLastFocusValues[]>);
              lastFocusUpdate: ((...params) => Promise<void>);
              message: (() => {
                  embed: (() => {
                      disable: ((...params) => Promise<void>);
                  });
              });
              messages: ((...params) => Promise<ChatMessage[]>);
              send: ((...params) => Promise<void>);
              typing: ((...params) => Promise<void>);
              unread: ((...params) => Promise<ChatUnreadResponse>);
          }

          • conversations: ((...params) => Promise<ChatConversation[]>)
          • conversationsCreate: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      metadata: string;
                      ownerMetadata: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • conversationsDelete: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • conversationsLeave: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • conversationsName: (() => {
                edit: ((...params) => Promise<void>);
            })
              • (): {
                    edit: ((...params) => Promise<void>);
                }

              • Returns {
                    edit: ((...params) => Promise<void>);
                }

                • edit: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            name: string;
                            uuid: string;
                        }]

                      Returns Promise<void>

          • conversationsOnline: ((...params) => Promise<ChatConversationsOnlineResponse>)
          • conversationsParticipants: (() => {
                add: ((...params) => Promise<void>);
                remove: ((...params) => Promise<void>);
            })
              • (): {
                    add: ((...params) => Promise<void>);
                    remove: ((...params) => Promise<void>);
                }

              • Returns {
                    add: ((...params) => Promise<void>);
                    remove: ((...params) => Promise<void>);
                }

                • add: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            contactUUID: string;
                            metadata: string;
                            uuid: string;
                        }]

                      Returns Promise<void>

                • remove: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            userId: number;
                            uuid: string;
                        }]

                      Returns Promise<void>

          • conversationsRead: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • conversationsUnread: ((...params) => Promise<ChatConversationsUnreadResponse>)
          • delete: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • edit: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      conversation: string;
                      message: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • lastFocus: ((...params) => Promise<ChatLastFocusValues[]>)
          • lastFocusUpdate: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                Returns Promise<void>

          • message: (() => {
                embed: (() => {
                    disable: ((...params) => Promise<void>);
                });
            })
              • (): {
                    embed: (() => {
                        disable: ((...params) => Promise<void>);
                    });
                }

              • Returns {
                    embed: (() => {
                        disable: ((...params) => Promise<void>);
                    });
                }

                • embed: (() => {
                      disable: ((...params) => Promise<void>);
                  })
                    • (): {
                          disable: ((...params) => Promise<void>);
                      }

                    • Returns {
                          disable: ((...params) => Promise<void>);
                      }

                      • disable: ((...params) => Promise<void>)
                          • (...params): Promise<void>

                          • Parameters

                            • Rest ...params: [{
                                  uuid: string;
                              }]

                            Returns Promise<void>

          • messages: ((...params) => Promise<ChatMessage[]>)
              • (...params): Promise<ChatMessage[]>

              • Parameters

                • Rest ...params: [{
                      conversation: string;
                      timestamp: number;
                  }]

                Returns Promise<ChatMessage[]>

          • send: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      conversation: string;
                      message: string;
                      replyTo: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • typing: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      conversation: string;
                      type: ChatTypingType;
                  }]

                Returns Promise<void>

          • unread: ((...params) => Promise<ChatUnreadResponse>)
    • confirmationSend: ((...params) => Promise<void>)
        • (...params): Promise<void>

        • Parameters

          • Rest ...params: [{
                email: string;
            }]

          Returns Promise<void>

    • contacts: (() => {
          all: ((...params) => Promise<ContactsResponse>);
          blocked: ((...params) => Promise<ContactsBlockedResponse>);
          blockedAdd: ((...params) => Promise<void>);
          blockedDelete: ((...params) => Promise<void>);
          delete: ((...params) => Promise<void>);
          requestsAccept: ((...params) => Promise<void>);
          requestsDeny: ((...params) => Promise<void>);
          requestsIn: ((...params) => Promise<ContactsRequestsInResponse>);
          requestsInCount: ((...params) => Promise<number>);
          requestsOut: ((...params) => Promise<ContactsRequestsOutResponse>);
          requestsOutDelete: ((...params) => Promise<void>);
          requestsSend: ((...params) => Promise<void>);
      })
        • (): {
              all: ((...params) => Promise<ContactsResponse>);
              blocked: ((...params) => Promise<ContactsBlockedResponse>);
              blockedAdd: ((...params) => Promise<void>);
              blockedDelete: ((...params) => Promise<void>);
              delete: ((...params) => Promise<void>);
              requestsAccept: ((...params) => Promise<void>);
              requestsDeny: ((...params) => Promise<void>);
              requestsIn: ((...params) => Promise<ContactsRequestsInResponse>);
              requestsInCount: ((...params) => Promise<number>);
              requestsOut: ((...params) => Promise<ContactsRequestsOutResponse>);
              requestsOutDelete: ((...params) => Promise<void>);
              requestsSend: ((...params) => Promise<void>);
          }

        • Returns {
              all: ((...params) => Promise<ContactsResponse>);
              blocked: ((...params) => Promise<ContactsBlockedResponse>);
              blockedAdd: ((...params) => Promise<void>);
              blockedDelete: ((...params) => Promise<void>);
              delete: ((...params) => Promise<void>);
              requestsAccept: ((...params) => Promise<void>);
              requestsDeny: ((...params) => Promise<void>);
              requestsIn: ((...params) => Promise<ContactsRequestsInResponse>);
              requestsInCount: ((...params) => Promise<number>);
              requestsOut: ((...params) => Promise<ContactsRequestsOutResponse>);
              requestsOutDelete: ((...params) => Promise<void>);
              requestsSend: ((...params) => Promise<void>);
          }

          • all: ((...params) => Promise<ContactsResponse>)
          • blocked: ((...params) => Promise<ContactsBlockedResponse>)
          • blockedAdd: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      email: string;
                  }]

                Returns Promise<void>

          • blockedDelete: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • delete: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • requestsAccept: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • requestsDeny: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • requestsIn: ((...params) => Promise<ContactsRequestsInResponse>)
          • requestsInCount: ((...params) => Promise<number>)
              • (...params): Promise<number>

              • Parameters

                • Rest ...params: []

                Returns Promise<number>

          • requestsOut: ((...params) => Promise<ContactsRequestsOutResponse>)
          • requestsOutDelete: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • requestsSend: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      email: string;
                  }]

                Returns Promise<void>

    • dir: (() => {
          color: ((...params) => Promise<void>);
          content: ((...params) => Promise<DirContentResponse>);
          create: ((...params) => Promise<DirCreateResponse>);
          delete: (() => {
              permanent: ((...params) => Promise<void>);
          });
          download: ((...params) => Promise<DirDownloadResponse>);
          exists: ((...params) => Promise<DirExistsResponse>);
          link: (() => {
              add: ((...params) => Promise<void>);
              content: ((...params) => Promise<DirLinkContentResponse>);
              edit: ((...params) => Promise<void>);
              info: ((...params) => Promise<DirLinkInfoResponse>);
              remove: ((...params) => Promise<void>);
              status: ((...params) => Promise<DirLinkStatusResponse>);
          });
          linked: ((...params) => Promise<DirLinkedResponse>);
          move: ((...params) => Promise<void>);
          present: ((...params) => Promise<DirPresentResponse>);
          rename: ((...params) => Promise<void>);
          restore: ((...params) => Promise<void>);
          shared: ((...params) => Promise<DirSharedResponse>);
          size: ((...params) => Promise<DirSizeResponse>);
          sizeLink: ((...params) => Promise<DirSizeLinkResponse>);
          trash: ((...params) => Promise<void>);
          tree: ((...params) => Promise<DirTreeResponse>);
      })
        • (): {
              color: ((...params) => Promise<void>);
              content: ((...params) => Promise<DirContentResponse>);
              create: ((...params) => Promise<DirCreateResponse>);
              delete: (() => {
                  permanent: ((...params) => Promise<void>);
              });
              download: ((...params) => Promise<DirDownloadResponse>);
              exists: ((...params) => Promise<DirExistsResponse>);
              link: (() => {
                  add: ((...params) => Promise<void>);
                  content: ((...params) => Promise<DirLinkContentResponse>);
                  edit: ((...params) => Promise<void>);
                  info: ((...params) => Promise<DirLinkInfoResponse>);
                  remove: ((...params) => Promise<void>);
                  status: ((...params) => Promise<DirLinkStatusResponse>);
              });
              linked: ((...params) => Promise<DirLinkedResponse>);
              move: ((...params) => Promise<void>);
              present: ((...params) => Promise<DirPresentResponse>);
              rename: ((...params) => Promise<void>);
              restore: ((...params) => Promise<void>);
              shared: ((...params) => Promise<DirSharedResponse>);
              size: ((...params) => Promise<DirSizeResponse>);
              sizeLink: ((...params) => Promise<DirSizeLinkResponse>);
              trash: ((...params) => Promise<void>);
              tree: ((...params) => Promise<DirTreeResponse>);
          }

        • Returns {
              color: ((...params) => Promise<void>);
              content: ((...params) => Promise<DirContentResponse>);
              create: ((...params) => Promise<DirCreateResponse>);
              delete: (() => {
                  permanent: ((...params) => Promise<void>);
              });
              download: ((...params) => Promise<DirDownloadResponse>);
              exists: ((...params) => Promise<DirExistsResponse>);
              link: (() => {
                  add: ((...params) => Promise<void>);
                  content: ((...params) => Promise<DirLinkContentResponse>);
                  edit: ((...params) => Promise<void>);
                  info: ((...params) => Promise<DirLinkInfoResponse>);
                  remove: ((...params) => Promise<void>);
                  status: ((...params) => Promise<DirLinkStatusResponse>);
              });
              linked: ((...params) => Promise<DirLinkedResponse>);
              move: ((...params) => Promise<void>);
              present: ((...params) => Promise<DirPresentResponse>);
              rename: ((...params) => Promise<void>);
              restore: ((...params) => Promise<void>);
              shared: ((...params) => Promise<DirSharedResponse>);
              size: ((...params) => Promise<DirSizeResponse>);
              sizeLink: ((...params) => Promise<DirSizeLinkResponse>);
              trash: ((...params) => Promise<void>);
              tree: ((...params) => Promise<DirTreeResponse>);
          }

          • color: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      color: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • content: ((...params) => Promise<DirContentResponse>)
          • create: ((...params) => Promise<DirCreateResponse>)
              • (...params): Promise<DirCreateResponse>

              • Parameters

                • Rest ...params: [{
                      metadataEncrypted: string;
                      nameHashed: string;
                      parent: string;
                      uuid?: string;
                  }]

                Returns Promise<DirCreateResponse>

          • delete: (() => {
                permanent: ((...params) => Promise<void>);
            })
              • (): {
                    permanent: ((...params) => Promise<void>);
                }

              • Returns {
                    permanent: ((...params) => Promise<void>);
                }

                • permanent: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            uuid: string;
                        }]

                      Returns Promise<void>

          • download: ((...params) => Promise<DirDownloadResponse>)
              • (...params): Promise<DirDownloadResponse>

              • Parameters

                • Rest ...params: [{
                      linkHasPassword?: boolean;
                      linkPassword?: string;
                      linkSalt?: string;
                      linkUUID?: string;
                      skipCache?: boolean;
                      type?: DirDownloadType;
                      uuid: string;
                  }]

                Returns Promise<DirDownloadResponse>

          • exists: ((...params) => Promise<DirExistsResponse>)
          • link: (() => {
                add: ((...params) => Promise<void>);
                content: ((...params) => Promise<DirLinkContentResponse>);
                edit: ((...params) => Promise<void>);
                info: ((...params) => Promise<DirLinkInfoResponse>);
                remove: ((...params) => Promise<void>);
                status: ((...params) => Promise<DirLinkStatusResponse>);
            })
              • (): {
                    add: ((...params) => Promise<void>);
                    content: ((...params) => Promise<DirLinkContentResponse>);
                    edit: ((...params) => Promise<void>);
                    info: ((...params) => Promise<DirLinkInfoResponse>);
                    remove: ((...params) => Promise<void>);
                    status: ((...params) => Promise<DirLinkStatusResponse>);
                }

              • Returns {
                    add: ((...params) => Promise<void>);
                    content: ((...params) => Promise<DirLinkContentResponse>);
                    edit: ((...params) => Promise<void>);
                    info: ((...params) => Promise<DirLinkInfoResponse>);
                    remove: ((...params) => Promise<void>);
                    status: ((...params) => Promise<DirLinkStatusResponse>);
                }

                • add: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            expiration: string;
                            key: string;
                            linkUUID: string;
                            metadata: string;
                            parent: string;
                            type: string;
                            uuid: string;
                        }]

                      Returns Promise<void>

                • content: ((...params) => Promise<DirLinkContentResponse>)
                • edit: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            downloadBtn: boolean;
                            expiration: PublicLinkExpiration;
                            password: string;
                            passwordHashed: string;
                            salt: string;
                            uuid: string;
                        }]

                      Returns Promise<void>

                • info: ((...params) => Promise<DirLinkInfoResponse>)
                • remove: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            uuid: string;
                        }]

                      Returns Promise<void>

                • status: ((...params) => Promise<DirLinkStatusResponse>)
          • linked: ((...params) => Promise<DirLinkedResponse>)
          • move: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      to: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • present: ((...params) => Promise<DirPresentResponse>)
          • rename: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      metadataEncrypted: string;
                      nameHashed: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • restore: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • shared: ((...params) => Promise<DirSharedResponse>)
          • size: ((...params) => Promise<DirSizeResponse>)
              • (...params): Promise<DirSizeResponse>

              • Parameters

                • Rest ...params: [{
                      receiverId?: number;
                      sharerId?: number;
                      trash?: boolean;
                      uuid: string;
                  }]

                Returns Promise<DirSizeResponse>

          • sizeLink: ((...params) => Promise<DirSizeLinkResponse>)
          • trash: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • tree: ((...params) => Promise<DirTreeResponse>)
              • (...params): Promise<DirTreeResponse>

              • Parameters

                • Rest ...params: [{
                      deviceId: string;
                      includeRaw?: boolean;
                      skipCache?: boolean;
                      uuid: string;
                  }]

                Returns Promise<DirTreeResponse>

    • file: (() => {
          delete: (() => {
              permanent: ((...params) => Promise<void>);
          });
          download: (() => {
              chunk: (() => {
                  buffer: ((...params) => Promise<Buffer>);
                  local: ((...params) => Promise<void>);
                  stream: ((...params) => Promise<ReadStream | ReadableStream<any>>);
              });
          });
          exists: ((...params) => Promise<FileExistsResponse>);
          link: (() => {
              edit: ((...params) => Promise<void>);
              info: ((...params) => Promise<FileLinkInfoResponse>);
              password: ((...params) => Promise<FileLinkPasswordResponse>);
              status: ((...params) => Promise<FileLinkStatusResponse>);
          });
          move: ((...params) => Promise<void>);
          rename: ((...params) => Promise<void>);
          restore: ((...params) => Promise<void>);
          trash: ((...params) => Promise<void>);
          upload: (() => {
              chunk: (() => {
                  buffer: ((...params) => Promise<UploadChunkResponse>);
              });
          });
          version: (() => {
              restore: ((...params) => Promise<void>);
          });
          versions: ((...params) => Promise<FileVersionsResponse>);
      })
        • (): {
              delete: (() => {
                  permanent: ((...params) => Promise<void>);
              });
              download: (() => {
                  chunk: (() => {
                      buffer: ((...params) => Promise<Buffer>);
                      local: ((...params) => Promise<void>);
                      stream: ((...params) => Promise<ReadStream | ReadableStream<any>>);
                  });
              });
              exists: ((...params) => Promise<FileExistsResponse>);
              link: (() => {
                  edit: ((...params) => Promise<void>);
                  info: ((...params) => Promise<FileLinkInfoResponse>);
                  password: ((...params) => Promise<FileLinkPasswordResponse>);
                  status: ((...params) => Promise<FileLinkStatusResponse>);
              });
              move: ((...params) => Promise<void>);
              rename: ((...params) => Promise<void>);
              restore: ((...params) => Promise<void>);
              trash: ((...params) => Promise<void>);
              upload: (() => {
                  chunk: (() => {
                      buffer: ((...params) => Promise<UploadChunkResponse>);
                  });
              });
              version: (() => {
                  restore: ((...params) => Promise<void>);
              });
              versions: ((...params) => Promise<FileVersionsResponse>);
          }

        • Returns {
              delete: (() => {
                  permanent: ((...params) => Promise<void>);
              });
              download: (() => {
                  chunk: (() => {
                      buffer: ((...params) => Promise<Buffer>);
                      local: ((...params) => Promise<void>);
                      stream: ((...params) => Promise<ReadStream | ReadableStream<any>>);
                  });
              });
              exists: ((...params) => Promise<FileExistsResponse>);
              link: (() => {
                  edit: ((...params) => Promise<void>);
                  info: ((...params) => Promise<FileLinkInfoResponse>);
                  password: ((...params) => Promise<FileLinkPasswordResponse>);
                  status: ((...params) => Promise<FileLinkStatusResponse>);
              });
              move: ((...params) => Promise<void>);
              rename: ((...params) => Promise<void>);
              restore: ((...params) => Promise<void>);
              trash: ((...params) => Promise<void>);
              upload: (() => {
                  chunk: (() => {
                      buffer: ((...params) => Promise<UploadChunkResponse>);
                  });
              });
              version: (() => {
                  restore: ((...params) => Promise<void>);
              });
              versions: ((...params) => Promise<FileVersionsResponse>);
          }

          • delete: (() => {
                permanent: ((...params) => Promise<void>);
            })
              • (): {
                    permanent: ((...params) => Promise<void>);
                }

              • Returns {
                    permanent: ((...params) => Promise<void>);
                }

                • permanent: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            uuid: string;
                        }]

                      Returns Promise<void>

          • download: (() => {
                chunk: (() => {
                    buffer: ((...params) => Promise<Buffer>);
                    local: ((...params) => Promise<void>);
                    stream: ((...params) => Promise<ReadStream | ReadableStream<any>>);
                });
            })
              • (): {
                    chunk: (() => {
                        buffer: ((...params) => Promise<Buffer>);
                        local: ((...params) => Promise<void>);
                        stream: ((...params) => Promise<ReadStream | ReadableStream<any>>);
                    });
                }

              • Returns {
                    chunk: (() => {
                        buffer: ((...params) => Promise<Buffer>);
                        local: ((...params) => Promise<void>);
                        stream: ((...params) => Promise<ReadStream | ReadableStream<any>>);
                    });
                }

                • chunk: (() => {
                      buffer: ((...params) => Promise<Buffer>);
                      local: ((...params) => Promise<void>);
                      stream: ((...params) => Promise<ReadStream | ReadableStream<any>>);
                  })
                    • (): {
                          buffer: ((...params) => Promise<Buffer>);
                          local: ((...params) => Promise<void>);
                          stream: ((...params) => Promise<ReadStream | ReadableStream<any>>);
                      }

                    • Returns {
                          buffer: ((...params) => Promise<Buffer>);
                          local: ((...params) => Promise<void>);
                          stream: ((...params) => Promise<ReadStream | ReadableStream<any>>);
                      }

                      • buffer: ((...params) => Promise<Buffer>)
                          • (...params): Promise<Buffer>

                          • Parameters

                            • Rest ...params: [{
                                  abortSignal?: AbortSignal;
                                  bucket: string;
                                  chunk: number;
                                  onProgress?: ProgressCallback;
                                  region: string;
                                  timeout?: number;
                                  uuid: string;
                              }]

                            Returns Promise<Buffer>

                      • local: ((...params) => Promise<void>)
                          • (...params): Promise<void>

                          • Parameters

                            • Rest ...params: [{
                                  abortSignal?: AbortSignal;
                                  bucket: string;
                                  chunk: number;
                                  onProgress?: ProgressCallback;
                                  region: string;
                                  timeout?: number;
                                  to: string;
                                  uuid: string;
                              }]

                            Returns Promise<void>

                      • stream: ((...params) => Promise<ReadStream | ReadableStream<any>>)
                          • (...params): Promise<ReadStream | ReadableStream<any>>

                          • Parameters

                            • Rest ...params: [{
                                  abortSignal?: AbortSignal;
                                  bucket: string;
                                  chunk: number;
                                  onProgress?: ProgressCallback;
                                  region: string;
                                  timeout?: number;
                                  uuid: string;
                              }]

                            Returns Promise<ReadStream | ReadableStream<any>>

          • exists: ((...params) => Promise<FileExistsResponse>)
          • link: (() => {
                edit: ((...params) => Promise<void>);
                info: ((...params) => Promise<FileLinkInfoResponse>);
                password: ((...params) => Promise<FileLinkPasswordResponse>);
                status: ((...params) => Promise<FileLinkStatusResponse>);
            })
          • move: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      to: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • rename: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      metadataEncrypted: string;
                      nameEncrypted: string;
                      nameHashed: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • restore: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • trash: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • upload: (() => {
                chunk: (() => {
                    buffer: ((...params) => Promise<UploadChunkResponse>);
                });
            })
              • (): {
                    chunk: (() => {
                        buffer: ((...params) => Promise<UploadChunkResponse>);
                    });
                }

              • Returns {
                    chunk: (() => {
                        buffer: ((...params) => Promise<UploadChunkResponse>);
                    });
                }

          • version: (() => {
                restore: ((...params) => Promise<void>);
            })
              • (): {
                    restore: ((...params) => Promise<void>);
                }

              • Returns {
                    restore: ((...params) => Promise<void>);
                }

                • restore: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            currentUUID: string;
                            uuid: string;
                        }]

                      Returns Promise<void>

          • versions: ((...params) => Promise<FileVersionsResponse>)
    • health: (() => Promise<"OK">)
        • (): Promise<"OK">

        • Returns Promise<"OK">

    • item: (() => {
          favorite: ((...params) => Promise<void>);
          linked: ((...params) => Promise<ItemLinkedResponse>);
          linkedRename: ((...params) => Promise<void>);
          share: ((...params) => Promise<void>);
          shared: ((...params) => Promise<ItemSharedResponse>);
          sharedIn: (() => {
              remove: ((...params) => Promise<void>);
          });
          sharedOut: (() => {
              remove: ((...params) => Promise<void>);
          });
          sharedRename: ((...params) => Promise<void>);
      })
        • (): {
              favorite: ((...params) => Promise<void>);
              linked: ((...params) => Promise<ItemLinkedResponse>);
              linkedRename: ((...params) => Promise<void>);
              share: ((...params) => Promise<void>);
              shared: ((...params) => Promise<ItemSharedResponse>);
              sharedIn: (() => {
                  remove: ((...params) => Promise<void>);
              });
              sharedOut: (() => {
                  remove: ((...params) => Promise<void>);
              });
              sharedRename: ((...params) => Promise<void>);
          }

        • Returns {
              favorite: ((...params) => Promise<void>);
              linked: ((...params) => Promise<ItemLinkedResponse>);
              linkedRename: ((...params) => Promise<void>);
              share: ((...params) => Promise<void>);
              shared: ((...params) => Promise<ItemSharedResponse>);
              sharedIn: (() => {
                  remove: ((...params) => Promise<void>);
              });
              sharedOut: (() => {
                  remove: ((...params) => Promise<void>);
              });
              sharedRename: ((...params) => Promise<void>);
          }

          • favorite: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      favorite: boolean;
                      type: "file" | "folder";
                      uuid: string;
                  }]

                Returns Promise<void>

          • linked: ((...params) => Promise<ItemLinkedResponse>)
          • linkedRename: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      linkUUID: string;
                      metadata: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • share: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      email: string;
                      metadata: string;
                      parent: string;
                      type: "file" | "folder";
                      uuid: string;
                  }]

                Returns Promise<void>

          • shared: ((...params) => Promise<ItemSharedResponse>)
          • sharedIn: (() => {
                remove: ((...params) => Promise<void>);
            })
              • (): {
                    remove: ((...params) => Promise<void>);
                }

              • Returns {
                    remove: ((...params) => Promise<void>);
                }

                • remove: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            uuid: string;
                        }]

                      Returns Promise<void>

          • sharedOut: (() => {
                remove: ((...params) => Promise<void>);
            })
              • (): {
                    remove: ((...params) => Promise<void>);
                }

              • Returns {
                    remove: ((...params) => Promise<void>);
                }

                • remove: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            receiverId: number;
                            uuid: string;
                        }]

                      Returns Promise<void>

          • sharedRename: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      metadata: string;
                      receiverId: number;
                      uuid: string;
                  }]

                Returns Promise<void>

    • login: ((...params) => Promise<LoginResponse>)
        • (...params): Promise<LoginResponse>

        • Parameters

          • Rest ...params: [{
                authVersion: AuthVersion;
                email: string;
                password: string;
                twoFactorCode?: string;
            }]

          Returns Promise<LoginResponse>

    • notes: (() => {
          all: ((...params) => Promise<NotesResponse>);
          archive: ((...params) => Promise<void>);
          content: ((...params) => Promise<NoteContent>);
          contentEdit: ((...params) => Promise<void>);
          create: ((...params) => Promise<void>);
          delete: ((...params) => Promise<void>);
          favorite: ((...params) => Promise<void>);
          history: ((...params) => Promise<NotesHistoryResponse>);
          historyRestore: ((...params) => Promise<void>);
          participantsAdd: ((...params) => Promise<void>);
          participantsPermissions: ((...params) => Promise<void>);
          participantsRemove: ((...params) => Promise<void>);
          pinned: ((...params) => Promise<void>);
          restore: ((...params) => Promise<void>);
          tag: ((...params) => Promise<void>);
          tags: ((...params) => Promise<NotesTagsResponse>);
          tagsCreate: ((...params) => Promise<NotesTagsCreateResponse>);
          tagsDelete: ((...params) => Promise<void>);
          tagsFavorite: ((...params) => Promise<void>);
          tagsRename: ((...params) => Promise<void>);
          titleEdit: ((...params) => Promise<void>);
          trash: ((...params) => Promise<void>);
          typeChange: ((...params) => Promise<void>);
          untag: ((...params) => Promise<void>);
      })
        • (): {
              all: ((...params) => Promise<NotesResponse>);
              archive: ((...params) => Promise<void>);
              content: ((...params) => Promise<NoteContent>);
              contentEdit: ((...params) => Promise<void>);
              create: ((...params) => Promise<void>);
              delete: ((...params) => Promise<void>);
              favorite: ((...params) => Promise<void>);
              history: ((...params) => Promise<NotesHistoryResponse>);
              historyRestore: ((...params) => Promise<void>);
              participantsAdd: ((...params) => Promise<void>);
              participantsPermissions: ((...params) => Promise<void>);
              participantsRemove: ((...params) => Promise<void>);
              pinned: ((...params) => Promise<void>);
              restore: ((...params) => Promise<void>);
              tag: ((...params) => Promise<void>);
              tags: ((...params) => Promise<NotesTagsResponse>);
              tagsCreate: ((...params) => Promise<NotesTagsCreateResponse>);
              tagsDelete: ((...params) => Promise<void>);
              tagsFavorite: ((...params) => Promise<void>);
              tagsRename: ((...params) => Promise<void>);
              titleEdit: ((...params) => Promise<void>);
              trash: ((...params) => Promise<void>);
              typeChange: ((...params) => Promise<void>);
              untag: ((...params) => Promise<void>);
          }

        • Returns {
              all: ((...params) => Promise<NotesResponse>);
              archive: ((...params) => Promise<void>);
              content: ((...params) => Promise<NoteContent>);
              contentEdit: ((...params) => Promise<void>);
              create: ((...params) => Promise<void>);
              delete: ((...params) => Promise<void>);
              favorite: ((...params) => Promise<void>);
              history: ((...params) => Promise<NotesHistoryResponse>);
              historyRestore: ((...params) => Promise<void>);
              participantsAdd: ((...params) => Promise<void>);
              participantsPermissions: ((...params) => Promise<void>);
              participantsRemove: ((...params) => Promise<void>);
              pinned: ((...params) => Promise<void>);
              restore: ((...params) => Promise<void>);
              tag: ((...params) => Promise<void>);
              tags: ((...params) => Promise<NotesTagsResponse>);
              tagsCreate: ((...params) => Promise<NotesTagsCreateResponse>);
              tagsDelete: ((...params) => Promise<void>);
              tagsFavorite: ((...params) => Promise<void>);
              tagsRename: ((...params) => Promise<void>);
              titleEdit: ((...params) => Promise<void>);
              trash: ((...params) => Promise<void>);
              typeChange: ((...params) => Promise<void>);
              untag: ((...params) => Promise<void>);
          }

          • all: ((...params) => Promise<NotesResponse>)
          • archive: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • content: ((...params) => Promise<NoteContent>)
              • (...params): Promise<NoteContent>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<NoteContent>

          • contentEdit: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      content: string;
                      preview: string;
                      type: NoteType;
                      uuid: string;
                  }]

                Returns Promise<void>

          • create: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      metadata: string;
                      title: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • delete: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • favorite: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      favorite: boolean;
                      uuid: string;
                  }]

                Returns Promise<void>

          • history: ((...params) => Promise<NotesHistoryResponse>)
          • historyRestore: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      id: number;
                      uuid: string;
                  }]

                Returns Promise<void>

          • participantsAdd: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      contactUUID: string;
                      metadata: string;
                      permissionsWrite: boolean;
                      uuid: string;
                  }]

                Returns Promise<void>

          • participantsPermissions: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      permissionsWrite: boolean;
                      userId: number;
                      uuid: string;
                  }]

                Returns Promise<void>

          • participantsRemove: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      userId: number;
                      uuid: string;
                  }]

                Returns Promise<void>

          • pinned: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      pinned: boolean;
                      uuid: string;
                  }]

                Returns Promise<void>

          • restore: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • tag: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      tag: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • tags: ((...params) => Promise<NotesTagsResponse>)
          • tagsCreate: ((...params) => Promise<NotesTagsCreateResponse>)
          • tagsDelete: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • tagsFavorite: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      favorite: boolean;
                      uuid: string;
                  }]

                Returns Promise<void>

          • tagsRename: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      name: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • titleEdit: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      title: string;
                      uuid: string;
                  }]

                Returns Promise<void>

          • trash: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<void>

          • typeChange: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      content: string;
                      preview: string;
                      type: NoteType;
                      uuid: string;
                  }]

                Returns Promise<void>

          • untag: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      tag: string;
                      uuid: string;
                  }]

                Returns Promise<void>

    • register: ((...params) => Promise<void>)
        • (...params): Promise<void>

        • Parameters

          • Rest ...params: [{
                authVersion: AuthVersion;
                email: string;
                password: string;
                salt: string;
            }]

          Returns Promise<void>

    • shared: (() => {
          in: ((...params) => Promise<SharedInResponse>);
          out: ((...params) => Promise<SharedOutResponse>);
      })
    • trash: (() => {
          empty: ((...params) => Promise<void>);
      })
        • (): {
              empty: ((...params) => Promise<void>);
          }

        • Returns {
              empty: ((...params) => Promise<void>);
          }

          • empty: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: []

                Returns Promise<void>

    • upload: (() => {
          done: ((...params) => Promise<UploadDoneResponse>);
      })
    • user: (() => {
          account: ((...params) => Promise<UserAccountResponse>);
          affiliate: (() => {
              payout: ((...params) => Promise<void>);
          });
          appearOffline: ((...params) => Promise<void>);
          avatar: ((...params) => Promise<void>);
          baseFolder: ((...params) => Promise<UserBaseFolderResponse>);
          delete: ((...params) => Promise<void>);
          deleteAll: ((...params) => Promise<void>);
          deleteVersions: ((...params) => Promise<void>);
          didExportMasterKeys: ((...params) => Promise<void>);
          event: ((...params) => Promise<UserEvent>);
          events: ((...params) => Promise<UserEvent[]>);
          gdpr: ((...params) => Promise<UserGDPRResponse>);
          info: ((...params) => Promise<UserInfoResponse>);
          invoice: ((...params) => Promise<string>);
          keyPair: (() => {
              info: ((...params) => Promise<UserKeyPairInfoResponse>);
              set: ((...params) => Promise<void>);
              update: ((...params) => Promise<void>);
          });
          lastActive: (() => {
              desktop: ((...params) => Promise<void>);
          });
          lock: ((...params) => Promise<UserLockResponse>);
          loginAlerts: ((...params) => Promise<void>);
          masterKeys: ((...params) => Promise<UserMasterKeysResponse>);
          nickname: ((...params) => Promise<void>);
          password: (() => {
              forgot: ((...params) => Promise<void>);
              forgotReset: ((...params) => Promise<void>);
          });
          personal: (() => {
              change: ((...params) => Promise<void>);
          });
          profile: ((...params) => Promise<UserProfileResponse>);
          publicKey: ((...params) => Promise<UserPublicKeyResponse>);
          settings: ((...params) => Promise<UserSettingsResponse>);
          settingsEmail: (() => {
              change: ((...params) => Promise<void>);
          });
          settingsPassword: (() => {
              change: ((...params) => Promise<UserSettingsPasswordChangeResponse>);
          });
          sub: (() => {
              cancel: ((...params) => Promise<void>);
              create: ((...params) => Promise<UserSubCreateResponse>);
          });
          twoFactorAuthentication: (() => {
              disable: ((...params) => Promise<void>);
              enable: ((...params) => Promise<User2FAEnableResponse>);
          });
          versioning: ((...params) => Promise<void>);
      })
        • (): {
              account: ((...params) => Promise<UserAccountResponse>);
              affiliate: (() => {
                  payout: ((...params) => Promise<void>);
              });
              appearOffline: ((...params) => Promise<void>);
              avatar: ((...params) => Promise<void>);
              baseFolder: ((...params) => Promise<UserBaseFolderResponse>);
              delete: ((...params) => Promise<void>);
              deleteAll: ((...params) => Promise<void>);
              deleteVersions: ((...params) => Promise<void>);
              didExportMasterKeys: ((...params) => Promise<void>);
              event: ((...params) => Promise<UserEvent>);
              events: ((...params) => Promise<UserEvent[]>);
              gdpr: ((...params) => Promise<UserGDPRResponse>);
              info: ((...params) => Promise<UserInfoResponse>);
              invoice: ((...params) => Promise<string>);
              keyPair: (() => {
                  info: ((...params) => Promise<UserKeyPairInfoResponse>);
                  set: ((...params) => Promise<void>);
                  update: ((...params) => Promise<void>);
              });
              lastActive: (() => {
                  desktop: ((...params) => Promise<void>);
              });
              lock: ((...params) => Promise<UserLockResponse>);
              loginAlerts: ((...params) => Promise<void>);
              masterKeys: ((...params) => Promise<UserMasterKeysResponse>);
              nickname: ((...params) => Promise<void>);
              password: (() => {
                  forgot: ((...params) => Promise<void>);
                  forgotReset: ((...params) => Promise<void>);
              });
              personal: (() => {
                  change: ((...params) => Promise<void>);
              });
              profile: ((...params) => Promise<UserProfileResponse>);
              publicKey: ((...params) => Promise<UserPublicKeyResponse>);
              settings: ((...params) => Promise<UserSettingsResponse>);
              settingsEmail: (() => {
                  change: ((...params) => Promise<void>);
              });
              settingsPassword: (() => {
                  change: ((...params) => Promise<UserSettingsPasswordChangeResponse>);
              });
              sub: (() => {
                  cancel: ((...params) => Promise<void>);
                  create: ((...params) => Promise<UserSubCreateResponse>);
              });
              twoFactorAuthentication: (() => {
                  disable: ((...params) => Promise<void>);
                  enable: ((...params) => Promise<User2FAEnableResponse>);
              });
              versioning: ((...params) => Promise<void>);
          }

        • Returns {
              account: ((...params) => Promise<UserAccountResponse>);
              affiliate: (() => {
                  payout: ((...params) => Promise<void>);
              });
              appearOffline: ((...params) => Promise<void>);
              avatar: ((...params) => Promise<void>);
              baseFolder: ((...params) => Promise<UserBaseFolderResponse>);
              delete: ((...params) => Promise<void>);
              deleteAll: ((...params) => Promise<void>);
              deleteVersions: ((...params) => Promise<void>);
              didExportMasterKeys: ((...params) => Promise<void>);
              event: ((...params) => Promise<UserEvent>);
              events: ((...params) => Promise<UserEvent[]>);
              gdpr: ((...params) => Promise<UserGDPRResponse>);
              info: ((...params) => Promise<UserInfoResponse>);
              invoice: ((...params) => Promise<string>);
              keyPair: (() => {
                  info: ((...params) => Promise<UserKeyPairInfoResponse>);
                  set: ((...params) => Promise<void>);
                  update: ((...params) => Promise<void>);
              });
              lastActive: (() => {
                  desktop: ((...params) => Promise<void>);
              });
              lock: ((...params) => Promise<UserLockResponse>);
              loginAlerts: ((...params) => Promise<void>);
              masterKeys: ((...params) => Promise<UserMasterKeysResponse>);
              nickname: ((...params) => Promise<void>);
              password: (() => {
                  forgot: ((...params) => Promise<void>);
                  forgotReset: ((...params) => Promise<void>);
              });
              personal: (() => {
                  change: ((...params) => Promise<void>);
              });
              profile: ((...params) => Promise<UserProfileResponse>);
              publicKey: ((...params) => Promise<UserPublicKeyResponse>);
              settings: ((...params) => Promise<UserSettingsResponse>);
              settingsEmail: (() => {
                  change: ((...params) => Promise<void>);
              });
              settingsPassword: (() => {
                  change: ((...params) => Promise<UserSettingsPasswordChangeResponse>);
              });
              sub: (() => {
                  cancel: ((...params) => Promise<void>);
                  create: ((...params) => Promise<UserSubCreateResponse>);
              });
              twoFactorAuthentication: (() => {
                  disable: ((...params) => Promise<void>);
                  enable: ((...params) => Promise<User2FAEnableResponse>);
              });
              versioning: ((...params) => Promise<void>);
          }

          • account: ((...params) => Promise<UserAccountResponse>)
          • affiliate: (() => {
                payout: ((...params) => Promise<void>);
            })
              • (): {
                    payout: ((...params) => Promise<void>);
                }

              • Returns {
                    payout: ((...params) => Promise<void>);
                }

                • payout: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            address: string;
                            method: string;
                        }]

                      Returns Promise<void>

          • appearOffline: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      appearOffline: boolean;
                  }]

                Returns Promise<void>

          • avatar: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      base64: string;
                      hash: string;
                  }]

                Returns Promise<void>

          • baseFolder: ((...params) => Promise<UserBaseFolderResponse>)
          • delete: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      twoFactorCode?: string;
                  }]

                Returns Promise<void>

          • deleteAll: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: []

                Returns Promise<void>

          • deleteVersions: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: []

                Returns Promise<void>

          • didExportMasterKeys: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: []

                Returns Promise<void>

          • event: ((...params) => Promise<UserEvent>)
              • (...params): Promise<UserEvent>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<UserEvent>

          • events: ((...params) => Promise<UserEvent[]>)
              • (...params): Promise<UserEvent[]>

              • Parameters

                • Rest ...params: [{
                      filter: string;
                      lastTimestamp: number;
                  }]

                Returns Promise<UserEvent[]>

          • gdpr: ((...params) => Promise<UserGDPRResponse>)
          • info: ((...params) => Promise<UserInfoResponse>)
          • invoice: ((...params) => Promise<string>)
              • (...params): Promise<string>

              • Parameters

                • Rest ...params: [{
                      uuid: string;
                  }]

                Returns Promise<string>

          • keyPair: (() => {
                info: ((...params) => Promise<UserKeyPairInfoResponse>);
                set: ((...params) => Promise<void>);
                update: ((...params) => Promise<void>);
            })
              • (): {
                    info: ((...params) => Promise<UserKeyPairInfoResponse>);
                    set: ((...params) => Promise<void>);
                    update: ((...params) => Promise<void>);
                }

              • Returns {
                    info: ((...params) => Promise<UserKeyPairInfoResponse>);
                    set: ((...params) => Promise<void>);
                    update: ((...params) => Promise<void>);
                }

                • info: ((...params) => Promise<UserKeyPairInfoResponse>)
                • set: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            apiKey?: string;
                            encryptedPrivateKey: string;
                            publicKey: string;
                        }]

                      Returns Promise<void>

                • update: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            apiKey?: string;
                            encryptedPrivateKey: string;
                            publicKey: string;
                        }]

                      Returns Promise<void>

          • lastActive: (() => {
                desktop: ((...params) => Promise<void>);
            })
              • (): {
                    desktop: ((...params) => Promise<void>);
                }

              • Returns {
                    desktop: ((...params) => Promise<void>);
                }

                • desktop: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            timestamp: number;
                        }]

                      Returns Promise<void>

          • lock: ((...params) => Promise<UserLockResponse>)
              • (...params): Promise<UserLockResponse>

              • Parameters

                • Rest ...params: [{
                      resource: string;
                      type: "status" | "acquire" | "refresh" | "release";
                      uuid: string;
                  }]

                Returns Promise<UserLockResponse>

          • loginAlerts: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      enable: boolean;
                  }]

                Returns Promise<void>

          • masterKeys: ((...params) => Promise<UserMasterKeysResponse>)
          • nickname: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      nickname: string;
                  }]

                Returns Promise<void>

          • password: (() => {
                forgot: ((...params) => Promise<void>);
                forgotReset: ((...params) => Promise<void>);
            })
              • (): {
                    forgot: ((...params) => Promise<void>);
                    forgotReset: ((...params) => Promise<void>);
                }

              • Returns {
                    forgot: ((...params) => Promise<void>);
                    forgotReset: ((...params) => Promise<void>);
                }

                • forgot: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            email: string;
                        }]

                      Returns Promise<void>

                • forgotReset: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            authVersion: number;
                            hasRecoveryKeys: boolean;
                            newMasterKeys: string;
                            password: string;
                            salt: string;
                            token: string;
                        }]

                      Returns Promise<void>

          • personal: (() => {
                change: ((...params) => Promise<void>);
            })
              • (): {
                    change: ((...params) => Promise<void>);
                }

              • Returns {
                    change: ((...params) => Promise<void>);
                }

                • change: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            city: string;
                            companyName: string;
                            country: string;
                            firstName: string;
                            lastName: string;
                            postalCode: string;
                            street: string;
                            streetNumber: string;
                            vatId: string;
                        }]

                      Returns Promise<void>

          • profile: ((...params) => Promise<UserProfileResponse>)
          • publicKey: ((...params) => Promise<UserPublicKeyResponse>)
          • settings: ((...params) => Promise<UserSettingsResponse>)
          • settingsEmail: (() => {
                change: ((...params) => Promise<void>);
            })
              • (): {
                    change: ((...params) => Promise<void>);
                }

              • Returns {
                    change: ((...params) => Promise<void>);
                }

                • change: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            authVersion: AuthVersion;
                            email: string;
                            password: string;
                        }]

                      Returns Promise<void>

          • settingsPassword: (() => {
                change: ((...params) => Promise<UserSettingsPasswordChangeResponse>);
            })
          • sub: (() => {
                cancel: ((...params) => Promise<void>);
                create: ((...params) => Promise<UserSubCreateResponse>);
            })
              • (): {
                    cancel: ((...params) => Promise<void>);
                    create: ((...params) => Promise<UserSubCreateResponse>);
                }

              • Returns {
                    cancel: ((...params) => Promise<void>);
                    create: ((...params) => Promise<UserSubCreateResponse>);
                }

          • twoFactorAuthentication: (() => {
                disable: ((...params) => Promise<void>);
                enable: ((...params) => Promise<User2FAEnableResponse>);
            })
              • (): {
                    disable: ((...params) => Promise<void>);
                    enable: ((...params) => Promise<User2FAEnableResponse>);
                }

              • Returns {
                    disable: ((...params) => Promise<void>);
                    enable: ((...params) => Promise<User2FAEnableResponse>);
                }

                • disable: ((...params) => Promise<void>)
                    • (...params): Promise<void>

                    • Parameters

                      • Rest ...params: [{
                            code: string;
                        }]

                      Returns Promise<void>

                • enable: ((...params) => Promise<User2FAEnableResponse>)
          • versioning: ((...params) => Promise<void>)
              • (...params): Promise<void>

              • Parameters

                • Rest ...params: [{
                      enable: boolean;
                  }]

                Returns Promise<void>

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc