Class FilenSDK

FilenSDK

Date

2/1/2024 - 2:45:02 AM

Export

Constructors

Properties

_api: API
_chats: Chats
_cloud: Cloud
_contacts: Contacts
_crypto: Crypto
_fs: FS
_notes: Notes
_updateKeyPairTries: number = 0
_user: User
axiosInstance: AxiosInstance
currentWorkerWorkIndex: number = 0
socket: Socket = ...
utils: {
    Uint8ArrayConcat: ((a1, a2) => Uint8Array);
    clearTempDirectory: ((param0) => Promise<void>);
    convertTimestampToMs: ((timestamp) => number);
    crypto: {
        bufferToHash: ((param0) => Promise<string>);
        derKeyToPem: ((param0) => Promise<string>);
        deriveKeyFromPassword: {
            (__namedParameters): Promise<Buffer>;
            (__namedParameters): Promise<string>;
        };
        generateKeyPair: (() => Promise<{
            privateKey: string;
            publicKey: string;
        }>);
        generatePasswordAndMasterKeyBasedOnAuthVersion: ((param0) => Promise<{
            derivedMasterKeys: string;
            derivedPassword: string;
        }>);
        generateRandomString: ((param0) => Promise<string>);
        hashFn: ((param0) => Promise<string>);
        hashPassword: ((param0) => Promise<string>);
        importPBKDF2Key: ((param0) => Promise<CryptoKey>);
        importPrivateKey: ((param0) => Promise<CryptoKey>);
        importPublicKey: ((param0) => Promise<CryptoKey>);
        importRawKey: ((param0) => Promise<CryptoKey>);
    };
    fastStringHash: ((input) => string);
    getEveryPossibleDirectoryPath: ((path) => string[]);
    getRandomArbitrary: ((min, max) => number);
    nodeStreamToBuffer: ((stream) => Promise<Buffer>);
    normalizePath: ((path) => string);
    parseURLParams: ((param0) => Record<string, string>);
    promiseAllChunked: (<T>(promises, chunkSize?) => Promise<T[]>);
    replacePathStartWithFromAndTo: ((path, from, to) => string);
    simpleDate: ((timestamp) => string);
    sleep: ((ms) => Promise<void>);
    streams: {
        append: ((param0) => Promise<number>);
        decodeBase64: ((param0) => Promise<string>);
        encodeBase64: ((param0) => Promise<string>);
    };
    uuidv4: (() => Promise<string>);
} = ...

Type declaration

  • Uint8ArrayConcat: ((a1, a2) => Uint8Array)
      • (a1, a2): Uint8Array
      • Concat two Uint8Arrays.

        Parameters

        • a1: Uint8Array
        • a2: Uint8Array

        Returns Uint8Array

        Date

        2/7/2024 - 5:13:31 AM

        Export

  • clearTempDirectory: ((param0) => Promise<void>)
      • (param0): Promise<void>
      • Clear the temporary directory.

        Parameters

        • param0: {
              tmpDir?: string;
          }
          • Optional tmpDir?: string

        Returns Promise<void>

        Date

        2/17/2024 - 1:15:42 AM

        Export

        Async

  • convertTimestampToMs: ((timestamp) => number)
      • (timestamp): number
      • Convert a UNIX style timestamp (in seconds) to milliseconds

        Parameters

        • timestamp: number

        Returns number

        Date

        1/31/2024 - 4:10:35 PM

        Export

  • crypto: {
        bufferToHash: ((param0) => Promise<string>);
        derKeyToPem: ((param0) => Promise<string>);
        deriveKeyFromPassword: {
            (__namedParameters): Promise<Buffer>;
            (__namedParameters): Promise<string>;
        };
        generateKeyPair: (() => Promise<{
            privateKey: string;
            publicKey: string;
        }>);
        generatePasswordAndMasterKeyBasedOnAuthVersion: ((param0) => Promise<{
            derivedMasterKeys: string;
            derivedPassword: string;
        }>);
        generateRandomString: ((param0) => Promise<string>);
        hashFn: ((param0) => Promise<string>);
        hashPassword: ((param0) => Promise<string>);
        importPBKDF2Key: ((param0) => Promise<CryptoKey>);
        importPrivateKey: ((param0) => Promise<CryptoKey>);
        importPublicKey: ((param0) => Promise<CryptoKey>);
        importRawKey: ((param0) => Promise<CryptoKey>);
    }
    • bufferToHash: ((param0) => Promise<string>)
        • (param0): Promise<string>
        • Generates the hash hex digest of a Buffer/Uint8Array.

          Parameters

          • param0: {
                algorithm: "sha512" | "sha256" | "md5";
                buffer: Uint8Array;
            }
            • algorithm: "sha512" | "sha256" | "md5"
            • buffer: Uint8Array

          Returns Promise<string>

          Date

          2/3/2024 - 2:03:24 AM

          Export

          Async

    • derKeyToPem: ((param0) => Promise<string>)
        • (param0): Promise<string>
        • Converts a public/private key in DER format to PEM.

          Parameters

          • param0: {
                key: string;
            }
            • key: string

          Returns Promise<string>

          Date

          2/2/2024 - 7:00:12 PM

          Export

          Async

    • deriveKeyFromPassword: {
          (__namedParameters): Promise<Buffer>;
          (__namedParameters): Promise<string>;
      }
    • generateKeyPair: (() => Promise<{
          privateKey: string;
          publicKey: string;
      }>)
        • (): Promise<{
              privateKey: string;
              publicKey: string;
          }>
        • Generate an asymmetric public/private keypair.

          Returns Promise<{
              privateKey: string;
              publicKey: string;
          }>

          Date

          2/6/2024 - 3:24:43 AM

          Export

          Async

    • generatePasswordAndMasterKeyBasedOnAuthVersion: ((param0) => Promise<{
          derivedMasterKeys: string;
          derivedPassword: string;
      }>)
        • (param0): Promise<{
              derivedMasterKeys: string;
              derivedPassword: string;
          }>
        • Generates/derives the password and master key based on the auth version. Auth Version 1 is deprecated and no longer in use.

          Parameters

          • param0: {
                authVersion: AuthVersion;
                rawPassword: string;
                salt: string;
            }
            • authVersion: AuthVersion
            • rawPassword: string
            • salt: string

          Returns Promise<{
              derivedMasterKeys: string;
              derivedPassword: string;
          }>

          Date

          2/2/2024 - 6:16:04 PM

          Export

          Async

    • generateRandomString: ((param0) => Promise<string>)
        • (param0): Promise<string>
        • Generate a cryptographically secure random string of given length.

          Parameters

          • param0: {
                length: number;
            }
            • length: number

          Returns Promise<string>

          Date

          1/31/2024 - 4:01:20 PM

          Export

    • hashFn: ((param0) => Promise<string>)
        • (param0): Promise<string>
        • Hashes an input (mostly file/folder names).

          Parameters

          • param0: {
                input: string;
            }
            • input: string

          Returns Promise<string>

          Date

          2/2/2024 - 6:59:32 PM

          Export

          Async

    • hashPassword: ((param0) => Promise<string>)
        • (param0): Promise<string>
        • Old V1 authentication password hashing. DEPRECATED AND NOT IN USE, JUST HERE FOR BACKWARDS COMPATIBILITY.

          Parameters

          • param0: {
                password: string;
            }
            • password: string

          Returns Promise<string>

          Date

          2/2/2024 - 6:59:54 PM

          Export

          Async

    • importPBKDF2Key: ((param0) => Promise<CryptoKey>)
        • (param0): Promise<CryptoKey>
        • Imports a PBKDF2 key into WebCrypto's format.

          Parameters

          • param0: {
                key: string;
                keyCache?: boolean;
                mode?: KeyUsage[];
            }
            • key: string
            • Optional keyCache?: boolean
            • Optional mode?: KeyUsage[]

          Returns Promise<CryptoKey>

          Date

          2/6/2024 - 8:56:57 PM

          Export

          Async

    • importPrivateKey: ((param0) => Promise<CryptoKey>)
        • (param0): Promise<CryptoKey>
        • Imports a base64 PCS8 private key to WebCrypto's format.

          Parameters

          • param0: {
                keyCache?: boolean;
                mode?: KeyUsage[];
                privateKey: string;
            }
            • Optional keyCache?: boolean
            • Optional mode?: KeyUsage[]
            • privateKey: string

          Returns Promise<CryptoKey>

          Date

          2/3/2024 - 1:44:39 AM

          Export

          Async

    • importPublicKey: ((param0) => Promise<CryptoKey>)
        • (param0): Promise<CryptoKey>
        • Imports a base64 encoded SPKI public key to WebCrypto's format.

          Parameters

          • param0: {
                keyCache?: boolean;
                mode?: KeyUsage[];
                publicKey: string;
            }
            • Optional keyCache?: boolean
            • Optional mode?: KeyUsage[]
            • publicKey: string

          Returns Promise<CryptoKey>

          Date

          2/2/2024 - 7:04:12 PM

          Export

          Async

    • importRawKey: ((param0) => Promise<CryptoKey>)
        • (param0): Promise<CryptoKey>
        • Imports a raw key to WebCrypto's fromat.

          Parameters

          • param0: {
                algorithm: "AES-GCM" | "AES-CBC";
                key: Buffer;
                keyCache?: boolean;
                mode?: KeyUsage[];
            }
            • algorithm: "AES-GCM" | "AES-CBC"
            • key: Buffer
            • Optional keyCache?: boolean
            • Optional mode?: KeyUsage[]

          Returns Promise<CryptoKey>

          Date

          3/6/2024 - 11:13:40 PM

          Export

          Async

  • fastStringHash: ((input) => string)
      • (input): string
      • Parameters

        • input: string

        Returns string

  • getEveryPossibleDirectoryPath: ((path) => string[])
      • (path): string[]
      • Extract every possible directory path from a path.

        Parameters

        • path: string

        Returns string[]

        Date

        2/19/2024 - 6:02:06 AM

        Export

  • getRandomArbitrary: ((min, max) => number)
      • (min, max): number
      • Generate a random number. NOT CRYPTOGRAPHICALLY SAFE.

        Parameters

        • min: number
        • max: number

        Returns number

        Date

        2/17/2024 - 1:08:06 AM

        Export

  • nodeStreamToBuffer: ((stream) => Promise<Buffer>)
  • normalizePath: ((path) => string)
      • (path): string
      • Normalizes a path to UNIX/Windows standards.

        Parameters

        • path: string

        Returns string

        Date

        2/5/2024 - 9:13:01 PM

        Export

  • parseURLParams: ((param0) => Record<string, string>)
      • (param0): Record<string, string>
      • Parse URL parameters.

        Parameters

        • param0: {
              url: string;
          }
          • url: string

        Returns Record<string, string>

        Date

        2/17/2024 - 4:57:54 AM

        Export

  • promiseAllChunked: (<T>(promises, chunkSize?) => Promise<T[]>)
      • <T>(promises, chunkSize?): Promise<T[]>
      • Chunk large Promise.all executions.

        Type Parameters

        • T

        Parameters

        • promises: Promise<T>[]
        • Optional chunkSize: number = 10000

        Returns Promise<T[]>

        Date

        2/14/2024 - 11:59:34 PM

        Export

        Async

  • replacePathStartWithFromAndTo: ((path, from, to) => string)
      • (path, from, to): string
      • Replace a path with it's new parent path.

        Parameters

        • path: string
        • from: string
        • to: string

        Returns string

        Export

  • simpleDate: ((timestamp) => string)
      • (timestamp): string
      • Convert a timestamp in ms to a simple date format

        Parameters

        • timestamp: number

        Returns string

        Date

        2/19/2024 - 11:48:39 PM

        Export

  • sleep: ((ms) => Promise<void>)
      • (ms): Promise<void>
      • "Sleep" for given milliseconds.

        Parameters

        • ms: number

        Returns Promise<void>

        Date

        1/31/2024 - 4:27:48 PM

        Export

        Async

  • streams: {
        append: ((param0) => Promise<number>);
        decodeBase64: ((param0) => Promise<string>);
        encodeBase64: ((param0) => Promise<string>);
    }
    • append: ((param0) => Promise<number>)
        • (param0): Promise<number>
        • Append one file to another using streams.

          Parameters

          • param0: {
                baseFile: string;
                inputFile: string;
            }
            • baseFile: string
            • inputFile: string

          Returns Promise<number>

          Date

          2/7/2024 - 5:13:02 AM

          Export

          Async

    • decodeBase64: ((param0) => Promise<string>)
        • (param0): Promise<string>
        • Decodes a base64 input file to an output file using streams.

          Parameters

          • param0: {
                inputFile: string;
                outputFile: string;
            }
            • inputFile: string
            • outputFile: string

          Returns Promise<string>

          Date

          2/7/2024 - 12:47:06 AM

          Export

          Async

    • encodeBase64: ((param0) => Promise<string>)
        • (param0): Promise<string>
        • Encodes a input file to an output file in base64 using streams.

          Parameters

          • param0: {
                inputFile: string;
                outputFile: string;
            }
            • inputFile: string
            • outputFile: string

          Returns Promise<string>

          Date

          2/10/2024 - 2:56:34 PM

          Export

          Async

  • uuidv4: (() => Promise<string>)
      • (): Promise<string>
      • Generates a V4 UUID.

        Returns Promise<string>

        Date

        2/6/2024 - 9:22:54 PM

        Export

        Async

workers: null | SDKWorker[]

Methods

  • Parameters

    • __namedParameters: {
          apiKey: string;
          masterKeys: string[];
      }
      • apiKey: string
      • masterKeys: string[]

    Returns Promise<{
        privateKey: string;
        publicKey: string;
    }>

  • Private

    Set keypair.

    Parameters

    • param0: {
          apiKey: string;
          masterKeys: string[];
          privateKey: string;
          publicKey: string;
      }
      • apiKey: string
      • masterKeys: string[]
      • privateKey: string
      • publicKey: string

    Returns Promise<void>

    Date

    2/20/2024 - 7:48:10 AM

    Async

  • Private

    Update keypair.

    Parameters

    • param0: {
          apiKey: string;
          masterKeys: string[];
          privateKey: string;
          publicKey: string;
      }
      • apiKey: string
      • masterKeys: string[]
      • privateKey: string
      • publicKey: string

    Returns Promise<void>

    Date

    2/20/2024 - 7:47:41 AM

    Async

  • Parameters

    • __namedParameters: {
          apiKey: string;
          masterKeys: string[];
      }
      • apiKey: string
      • masterKeys: string[]

    Returns Promise<{
        masterKeys: string[];
        privateKey: string;
        publicKey: string;
    }>

  • Parameters

    • version: number

    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>);
            get: ((...params) => Promise<DirGetResponse>);
            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<ReadableStream<any> | ReadStream>);
                });
            });
            exists: ((...params) => Promise<FileExistsResponse>);
            get: ((...params) => Promise<FileGetResponse>);
            link: (() => {
                edit: ((...params) => Promise<void>);
                info: ((...params) => Promise<FileLinkInfoResponse>);
                password: ((...params) => Promise<FileLinkPasswordResponse>);
                status: ((...params) => Promise<FileLinkStatusResponse>);
            });
            move: ((...params) => Promise<void>);
            present: ((...params) => Promise<FilePresentResponse>);
            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>);
          get: ((...params) => Promise<DirGetResponse>);
          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>);
              get: ((...params) => Promise<DirGetResponse>);
              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>);
              get: ((...params) => Promise<DirGetResponse>);
              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>)
          • get: ((...params) => Promise<DirGetResponse>)
          • 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<ReadableStream<any> | ReadStream>);
              });
          });
          exists: ((...params) => Promise<FileExistsResponse>);
          get: ((...params) => Promise<FileGetResponse>);
          link: (() => {
              edit: ((...params) => Promise<void>);
              info: ((...params) => Promise<FileLinkInfoResponse>);
              password: ((...params) => Promise<FileLinkPasswordResponse>);
              status: ((...params) => Promise<FileLinkStatusResponse>);
          });
          move: ((...params) => Promise<void>);
          present: ((...params) => Promise<FilePresentResponse>);
          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<ReadableStream<any> | ReadStream>);
                  });
              });
              exists: ((...params) => Promise<FileExistsResponse>);
              get: ((...params) => Promise<FileGetResponse>);
              link: (() => {
                  edit: ((...params) => Promise<void>);
                  info: ((...params) => Promise<FileLinkInfoResponse>);
                  password: ((...params) => Promise<FileLinkPasswordResponse>);
                  status: ((...params) => Promise<FileLinkStatusResponse>);
              });
              move: ((...params) => Promise<void>);
              present: ((...params) => Promise<FilePresentResponse>);
              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<ReadableStream<any> | ReadStream>);
                  });
              });
              exists: ((...params) => Promise<FileExistsResponse>);
              get: ((...params) => Promise<FileGetResponse>);
              link: (() => {
                  edit: ((...params) => Promise<void>);
                  info: ((...params) => Promise<FileLinkInfoResponse>);
                  password: ((...params) => Promise<FileLinkPasswordResponse>);
                  status: ((...params) => Promise<FileLinkStatusResponse>);
              });
              move: ((...params) => Promise<void>);
              present: ((...params) => Promise<FilePresentResponse>);
              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<ReadableStream<any> | ReadStream>);
                });
            })
              • (): {
                    chunk: (() => {
                        buffer: ((...params) => Promise<Buffer>);
                        local: ((...params) => Promise<void>);
                        stream: ((...params) => Promise<ReadableStream<any> | ReadStream>);
                    });
                }
              • Returns {
                    chunk: (() => {
                        buffer: ((...params) => Promise<Buffer>);
                        local: ((...params) => Promise<void>);
                        stream: ((...params) => Promise<ReadableStream<any> | ReadStream>);
                    });
                }

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

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

                            • Rest ...params: [{
                                  abortSignal?: AbortSignal;
                                  bucket: string;
                                  chunk: number;
                                  onProgress?: ProgressCallback;
                                  onProgressId?: string;
                                  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;
                                  onProgressId?: string;
                                  region: string;
                                  timeout?: number;
                                  to: string;
                                  uuid: string;
                              }]

                            Returns Promise<void>

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

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

                            Returns Promise<ReadableStream<any> | ReadStream>

          • exists: ((...params) => Promise<FileExistsResponse>)
          • get: ((...params) => Promise<FileGetResponse>)
          • 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>

          • present: ((...params) => Promise<FilePresentResponse>)
          • 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>);
                    });
                }

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

                      • buffer: ((...params) => Promise<UploadChunkResponse>)
                          • (...params): Promise<UploadChunkResponse>
                          • Parameters

                            • Rest ...params: [{
                                  abortSignal?: AbortSignal;
                                  buffer: Buffer;
                                  index: number;
                                  maxRetries?: number;
                                  onProgress?: ProgressCallback;
                                  onProgressId?: string;
                                  parent: string;
                                  retryTimeout?: number;
                                  timeout?: number;
                                  uploadKey: string;
                                  uuid: string;
                              }]

                            Returns 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: [{
                affId?: string;
                authVersion: AuthVersion;
                email: string;
                password: string;
                refId?: 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) =>