Class FilenSDK

FilenSDK

Date

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

Export

Constructors

constructor

new FilenSDK(params?, workers?, axiosInstance?): FilenSDK
Creates an instance of FilenSDK.
Parameters
- Optional params: FilenSDKConfig
- Optional workers: SDKWorker[]
- Optional axiosInstance: AxiosInstance
Returns FilenSDK
- Defined in src/index.ts:99

Properties

`Private` _api

_api: API

`Private` _chats

_chats: Chats

`Private` _cloud

_cloud: Cloud

`Private` _contacts

_contacts: Contacts

`Private` _crypto

_crypto: Crypto

`Private` _fs

_fs: FS

`Private` _notes

_notes: Notes

`Private` _updateKeyPairTries

_updateKeyPairTries: number = 0

`Private` _user

_user: User

`Readonly` axiosInstance

axiosInstance: AxiosInstance

config

config: FilenSDKConfig

`Private` currentWorkerWorkIndex

currentWorkerWorkIndex: number = 0

`Readonly` events

events: TypedEventEmitter<Events>

socket

socket: Socket = ...

`Readonly` utils

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>;
  }
  - - (__namedParameters): Promise<Buffer>
    - Parameters
      __namedParameters: DeriveKeyFromPasswordBase & {
      returnHex: false;
      }
      Returns Promise<Buffer>
    - (__namedParameters): Promise<string>
    - Parameters
      __namedParameters: DeriveKeyFromPasswordBase & {
      returnHex: true;
      }
      Returns 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>)
- - (stream): Promise<Buffer>
  - Parameters
    - stream: Readable
    Returns 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

workers: null | SDKWorker[]

Methods

`Private` __updateKeyPair

__updateKeyPair(__namedParameters): Promise<{
privateKey: string;
publicKey: string;
}>
Parameters
- __namedParameters: {
  apiKey: string;
  masterKeys: string[];
  }
  - apiKey: string
  - masterKeys: string[]
Returns Promise<{
privateKey: string;
publicKey: string;
}>
- Defined in src/index.ts:469

`Private` _setKeyPair

_setKeyPair(param0): Promise<void>
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
- Defined in src/index.ts:446

`Private` _updateKeyPair

_updateKeyPair(param0): Promise<void>
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
- Defined in src/index.ts:410

`Private` _updateKeys

_updateKeys(__namedParameters): Promise<{
    masterKeys: string[];
    privateKey: string;
    publicKey: string;
}>
Parameters
- __namedParameters: {
  apiKey: string;
  masterKeys: string[];
  }
  - apiKey: string
  - masterKeys: string[]
Returns Promise<{
    masterKeys: string[];
    privateKey: string;
    publicKey: string;
}>
- Defined in src/index.ts:560

api

api(version): {
    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>);
    });
}
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>);
  })
  - - (): {
      info: ((...params) => Promise<AuthInfoResponse>);
      }
    - Returns {
      info: ((...params) => Promise<AuthInfoResponse>);
      }
      - info: ((...params) => Promise<AuthInfoResponse>)
        (...params): Promise<AuthInfoResponse>
        Parameters
        Rest ...params: [{
        email: string;
        }]
        Returns 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[]>)
        (...params): Promise<ChatConversation[]>
        Parameters
        Rest ...params: []
        Returns 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>)
        (...params): Promise<ChatConversationsOnlineResponse>
        Parameters
        Rest ...params: [{
        conversation: string;
        }]
        Returns 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>)
        (...params): Promise<ChatConversationsUnreadResponse>
        Parameters
        Rest ...params: [{
        uuid: string;
        }]
        Returns 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[]>)
        (...params): Promise<ChatLastFocusValues[]>
        Parameters
        Rest ...params: []
        Returns Promise<ChatLastFocusValues[]>
      - lastFocusUpdate: ((...params) => Promise<void>)
        (...params): Promise<void>
        Parameters
        Rest ...params: [{
        conversations: ChatLastFocusValues[];
        }]
        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>)
        (...params): Promise<ChatUnreadResponse>
        Parameters
        Rest ...params: []
        Returns 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>)
        (...params): Promise<ContactsResponse>
        Parameters
        Rest ...params: []
        Returns Promise<ContactsResponse>
      - blocked: ((...params) => Promise<ContactsBlockedResponse>)
        (...params): Promise<ContactsBlockedResponse>
        Parameters
        Rest ...params: []
        Returns 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>)
        (...params): Promise<ContactsRequestsInResponse>
        Parameters
        Rest ...params: []
        Returns Promise<ContactsRequestsInResponse>
      - requestsInCount: ((...params) => Promise<number>)
        (...params): Promise<number>
        Parameters
        Rest ...params: []
        Returns Promise<number>
      - requestsOut: ((...params) => Promise<ContactsRequestsOutResponse>)
        (...params): Promise<ContactsRequestsOutResponse>
        Parameters
        Rest ...params: []
        Returns 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>)
        (...params): Promise<DirContentResponse>
        Parameters
        Rest ...params: [{
        dirsOnly?: boolean;
        uuid: string;
        }]
        Returns 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>)
        (...params): Promise<DirExistsResponse>
        Parameters
        Rest ...params: [{
        nameHashed: string;
        parent: string;
        }]
        Returns Promise<DirExistsResponse>
      - get: ((...params) => Promise<DirGetResponse>)
        (...params): Promise<DirGetResponse>
        Parameters
        Rest ...params: [{
        uuid: string;
        }]
        Returns 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>)
        (...params): Promise<DirLinkContentResponse>
        Parameters
        Rest ...params: [{
            parent: string;
            password: string;
            uuid: string;
        }]
        Returns 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>)
        (...params): Promise<DirLinkInfoResponse>
        Parameters
        Rest ...params: [{
            uuid: string;
        }]
        Returns Promise<DirLinkInfoResponse>
        remove: ((...params) => Promise<void>)
        (...params): Promise<void>
        Parameters
        Rest ...params: [{
            uuid: string;
        }]
        Returns Promise<void>
        status: ((...params) => Promise<DirLinkStatusResponse>)
        (...params): Promise<DirLinkStatusResponse>
        Parameters
        Rest ...params: [{
            uuid: string;
        }]
        Returns Promise<DirLinkStatusResponse>
      - linked: ((...params) => Promise<DirLinkedResponse>)
        (...params): Promise<DirLinkedResponse>
        Parameters
        Rest ...params: [{
        uuid: string;
        }]
        Returns Promise<DirLinkedResponse>
      - move: ((...params) => Promise<void>)
        (...params): Promise<void>
        Parameters
        Rest ...params: [{
        to: string;
        uuid: string;
        }]
        Returns Promise<void>
      - present: ((...params) => Promise<DirPresentResponse>)
        (...params): Promise<DirPresentResponse>
        Parameters
        Rest ...params: [{
        uuid: string;
        }]
        Returns 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>)
        (...params): Promise<DirSharedResponse>
        Parameters
        Rest ...params: [{
        uuid: string;
        }]
        Returns 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>)
        (...params): Promise<DirSizeLinkResponse>
        Parameters
        Rest ...params: [{
        linkUUID: string;
        uuid: string;
        }]
        Returns 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>)
        (...params): Promise<FileExistsResponse>
        Parameters
        Rest ...params: [{
        nameHashed: string;
        parent: string;
        }]
        Returns Promise<FileExistsResponse>
      - get: ((...params) => Promise<FileGetResponse>)
        (...params): Promise<FileGetResponse>
        Parameters
        Rest ...params: [{
        uuid: string;
        }]
        Returns Promise<FileGetResponse>
      - link: (() => {
            edit: ((...params) => Promise<void>);
            info: ((...params) => Promise<FileLinkInfoResponse>);
            password: ((...params) => Promise<FileLinkPasswordResponse>);
            status: ((...params) => Promise<FileLinkStatusResponse>);
        })
        (): {
            edit: ((...params) => Promise<void>);
            info: ((...params) => Promise<FileLinkInfoResponse>);
            password: ((...params) => Promise<FileLinkPasswordResponse>);
            status: ((...params) => Promise<FileLinkStatusResponse>);
        }
        Returns {
            edit: ((...params) => Promise<void>);
            info: ((...params) => Promise<FileLinkInfoResponse>);
            password: ((...params) => Promise<FileLinkPasswordResponse>);
            status: ((...params) => Promise<FileLinkStatusResponse>);
        }
        edit: ((...params) => Promise<void>)
        (...params): Promise<void>
        Parameters
        Rest ...params: [{
            downloadBtn: boolean;
            expiration: PublicLinkExpiration;
            fileUUID: string;
            password: string;
            passwordHashed: string;
            salt: string;
            type: "enable" | "disable";
            uuid: string;
        }]
        Returns Promise<void>
        info: ((...params) => Promise<FileLinkInfoResponse>)
        (...params): Promise<FileLinkInfoResponse>
        Parameters
        Rest ...params: [{
            password: string;
            uuid: string;
        }]
        Returns Promise<FileLinkInfoResponse>
        password: ((...params) => Promise<FileLinkPasswordResponse>)
        (...params): Promise<FileLinkPasswordResponse>
        Parameters
        Rest ...params: [{
            uuid: string;
        }]
        Returns Promise<FileLinkPasswordResponse>
        status: ((...params) => Promise<FileLinkStatusResponse>)
        (...params): Promise<FileLinkStatusResponse>
        Parameters
        Rest ...params: [{
            uuid: string;
        }]
        Returns Promise<FileLinkStatusResponse>
      - move: ((...params) => Promise<void>)
        (...params): Promise<void>
        Parameters
        Rest ...params: [{
        to: string;
        uuid: string;
        }]
        Returns Promise<void>
      - present: ((...params) => Promise<FilePresentResponse>)
        (...params): Promise<FilePresentResponse>
        Parameters
        Rest ...params: [{
        uuid: string;
        }]
        Returns 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>)
        (...params): Promise<FileVersionsResponse>
        Parameters
        Rest ...params: [{
        uuid: string;
        }]
        Returns 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>)
        (...params): Promise<ItemLinkedResponse>
        Parameters
        Rest ...params: [{
        uuid: string;
        }]
        Returns 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>)
        (...params): Promise<ItemSharedResponse>
        Parameters
        Rest ...params: [{
        uuid: string;
        }]
        Returns 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>)
        (...params): Promise<NotesResponse>
        Parameters
        Rest ...params: []
        Returns 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>)
        (...params): Promise<NotesHistoryResponse>
        Parameters
        Rest ...params: [{
        uuid: string;
        }]
        Returns 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>)
        (...params): Promise<NotesTagsResponse>
        Parameters
        Rest ...params: []
        Returns Promise<NotesTagsResponse>
      - tagsCreate: ((...params) => Promise<NotesTagsCreateResponse>)
        (...params): Promise<NotesTagsCreateResponse>
        Parameters
        Rest ...params: [{
        name: string;
        }]
        Returns 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>);
  })
  - - (): {
      in: ((...params) => Promise<SharedInResponse>);
      out: ((...params) => Promise<SharedOutResponse>);
      }
    - Returns {
      in: ((...params) => Promise<SharedInResponse>);
      out: ((...params) => Promise<SharedOutResponse>);
      }
      - in: ((...params) => Promise<SharedInResponse>)
        (...params): Promise<SharedInResponse>
        Parameters
        Rest ...params: [params?: {
        uuid?: string;
        }]
        Returns Promise<SharedInResponse>
      - out: ((...params) => Promise<SharedOutResponse>)
        (...params): Promise<SharedOutResponse>
        Parameters
        Rest ...params: [params?: {
        receiverId?: number;
        uuid?: string;
        }]
        Returns 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>);
  })
  - - (): {
      done: ((...params) => Promise<UploadDoneResponse>);
      }
    - Returns {
      done: ((...params) => Promise<UploadDoneResponse>);
      }
      - done: ((...params) => Promise<UploadDoneResponse>)
        (...params): Promise<UploadDoneResponse>
        Parameters
        Rest ...params: [{
            chunks: number;
            metadata: string;
            mime: string;
            name: string;
            nameHashed: string;
            rm: string;
            size: string;
            uploadKey: string;
            uuid: string;
            version: FileEncryptionVersion;
        }]
        Returns 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>)
        (...params): Promise<UserAccountResponse>
        Parameters
        Rest ...params: []
        Returns 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>)
        (...params): Promise<UserBaseFolderResponse>
        Parameters
        Rest ...params: [{
        apiKey?: string;
        }]
        Returns 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>)
        (...params): Promise<UserGDPRResponse>
        Parameters
        Rest ...params: []
        Returns Promise<UserGDPRResponse>
      - info: ((...params) => Promise<UserInfoResponse>)
        (...params): Promise<UserInfoResponse>
        Parameters
        Rest ...params: [{
        apiKey?: string;
        }]
        Returns 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>)
        (...params): Promise<UserKeyPairInfoResponse>
        Parameters
        Rest ...params: [{
            apiKey?: string;
        }]
        Returns 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: "acquire" | "refresh" | "status" | "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>)
        (...params): Promise<UserMasterKeysResponse>
        Parameters
        Rest ...params: [{
        apiKey?: string;
        encryptedMasterKeys: string;
        }]
        Returns 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>)
        (...params): Promise<UserProfileResponse>
        Parameters
        Rest ...params: [{
        id: number;
        }]
        Returns Promise<UserProfileResponse>
      - publicKey: ((...params) => Promise<UserPublicKeyResponse>)
        (...params): Promise<UserPublicKeyResponse>
        Parameters
        Rest ...params: [{
        email: string;
        }]
        Returns Promise<UserPublicKeyResponse>
      - settings: ((...params) => Promise<UserSettingsResponse>)
        (...params): Promise<UserSettingsResponse>
        Parameters
        Rest ...params: []
        Returns 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>);
        })
        (): {
            change: ((...params) => Promise<UserSettingsPasswordChangeResponse>);
        }
        Returns {
            change: ((...params) => Promise<UserSettingsPasswordChangeResponse>);
        }
        change: ((...params) => Promise<UserSettingsPasswordChangeResponse>)
        (...params): Promise<UserSettingsPasswordChangeResponse>
        Parameters
        Rest ...params: [{
            authVersion: AuthVersion;
            currentPassword: string;
            masterKeys: string;
            password: string;
            salt: string;
        }]
        Returns 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>);
        }
        cancel: ((...params) => Promise<void>)
        (...params): Promise<void>
        Parameters
        Rest ...params: [{
            uuid: string;
        }]
        Returns Promise<void>
        create: ((...params) => Promise<UserSubCreateResponse>)
        (...params): Promise<UserSubCreateResponse>
        Parameters
        Rest ...params: [{
            method: PaymentMethods;
            planId: number;
        }]
        Returns 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>)
        (...params): Promise<User2FAEnableResponse>
        Parameters
        Rest ...params: [{
            code: string;
        }]
        Returns Promise<User2FAEnableResponse>
      - versioning: ((...params) => Promise<void>)
        (...params): Promise<void>
        Parameters
        Rest ...params: [{
        enable: boolean;
        }]
        Returns Promise<void>
- Defined in src/index.ts:706

chats

chats(): Chats
Returns an instance of Chats.

Returns Chats
Date
2/19/2024 - 6:32:35 AM
- Defined in src/index.ts:785

clearTemporaryDirectory

clearTemporaryDirectory(): Promise<void>
Clear the temporary directory. Only available in a Node.JS environment.

Returns Promise<void>
Date
2/17/2024 - 1:51:39 AM

Async
- Defined in src/index.ts:831

cloud

cloud(): Cloud
Returns an instance of Cloud.

Returns Cloud
Date
2/17/2024 - 1:52:05 AM
- Defined in src/index.ts:755

contacts

contacts(): Contacts
Returns an instance of Contacts.

Returns Contacts
Date
2/20/2024 - 6:27:05 AM
- Defined in src/index.ts:800

crypto

crypto(): Crypto
Returns an instance of Crypto.

Returns Crypto
Date
1/31/2024 - 4:29:49 PM
- Defined in src/index.ts:725

fs

fs(): FS
Returns an instance of FS.

Returns FS
Date
2/17/2024 - 1:52:12 AM
- Defined in src/index.ts:740

getBaseWorker

getBaseWorker(): SDKWorker
Returns SDKWorker
- Defined in src/index.ts:193

getWorker

getWorker(): SDKWorker
Get a worker from the SDK Worker pool if set. Greatly improves performance.

Returns SDKWorker
- Defined in src/index.ts:235

init

init(params): void
Initialize the SDK again (after logging in for example).
Parameters
- params: FilenSDKConfig
Returns void
Date
2/1/2024 - 3:23:58 PM
- Defined in src/index.ts:294

`Private` isLoggedIn

isLoggedIn(): boolean
Private
Check if the SDK user is authenticated.

Returns boolean
Date
1/31/2024 - 4:08:17 PM
- Defined in src/index.ts:378

login

login(param0): Promise<void>
Authenticate.
Parameters
- param0: {
      email?: string;
      password?: string;
      twoFactorCode?: string;
  }
  - Optional email?: string
  - Optional password?: string
  - Optional twoFactorCode?: string
Returns Promise<void>
Date
2/20/2024 - 7:24:10 AM

Async
- Defined in src/index.ts:634

logout

logout(): void
Logout.

Returns void
Date
2/9/2024 - 5:48:28 AM
- Defined in src/index.ts:690

notes

notes(): Notes
Returns an instance of Notes.

Returns Notes
Date
2/19/2024 - 6:32:35 AM
- Defined in src/index.ts:770

setSDKWorkers

setSDKWorkers(sdkWorkers): void
Update the SDK Worker pool.
Parameters
- sdkWorkers: SDKWorker[]
Returns void
- Defined in src/index.ts:189

user

user(): User
Return an instance of User.

Returns User
Date
2/20/2024 - 6:27:17 AM
- Defined in src/index.ts:815

Class FilenSDK

Date

Export

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Optional params: FilenSDKConfig

Optional workers: SDKWorker[]

Optional axiosInstance: AxiosInstance

Returns FilenSDK

Properties

Private _api

Private _chats

Private _cloud

Private _contacts

Private _crypto

Private _fs

Private _notes

Private _updateKeyPairTries

Private _user

Readonly axiosInstance

config

Private currentWorkerWorkIndex

Readonly events

socket

Readonly utils

Type declaration

Uint8ArrayConcat: ((a1, a2) => Uint8Array)

Parameters

a1: Uint8Array

a2: Uint8Array

Returns Uint8Array

Date

Export

clearTempDirectory: ((param0) => Promise<void>)

Parameters

param0: { tmpDir?: string; }

Optional tmpDir?: string

Returns Promise<void>

Date

Export

Async

convertTimestampToMs: ((timestamp) => number)

Parameters

timestamp: number

Returns number

Date

Export

bufferToHash: ((param0) => Promise<string>)

Parameters

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

algorithm: "sha512" | "sha256" | "md5"

buffer: Uint8Array

Returns Promise<string>

Date

Export

Async

derKeyToPem: ((param0) => Promise<string>)

Parameters

param0: { key: string; }

key: string

Returns Promise<string>

Date

Export

Async

deriveKeyFromPassword: { (__namedParameters): Promise<Buffer>; (__namedParameters): Promise<string>; }

Parameters

__namedParameters: DeriveKeyFromPasswordBase & { returnHex: false; }

Returns Promise<Buffer>

Parameters

__namedParameters: DeriveKeyFromPasswordBase & { returnHex: true; }

Returns Promise<string>

generateKeyPair: (() => Promise<{ privateKey: string; publicKey: string; }>)

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

Date

Export

`Optional` params: FilenSDKConfig

`Optional` workers: SDKWorker[]

`Optional` axiosInstance: AxiosInstance

`Private` _api

`Private` _chats

`Private` _cloud

`Private` _contacts

`Private` _crypto

`Private` _fs

`Private` _notes

`Private` _updateKeyPairTries

`Private` _user

`Readonly` axiosInstance

`Private` currentWorkerWorkIndex

`Readonly` events

`Readonly` utils

param0: {
tmpDir?: string;
}

`Optional` tmpDir?: string

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

param0: {
key: string;
}

deriveKeyFromPassword: {
(namedParameters): Promise<Buffer>;
(namedParameters): Promise<string>;
}

__namedParameters: DeriveKeyFromPasswordBase & {
returnHex: false;
}

__namedParameters: DeriveKeyFromPasswordBase & {
returnHex: true;
}

generateKeyPair: (() => Promise<{
privateKey: string;
publicKey: string;
}>)

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

generatePasswordAndMasterKeyBasedOnAuthVersion: ((param0) => Promise<{
derivedMasterKeys: string;
derivedPassword: string;
}>)

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

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

param0: {
length: number;
}

param0: {
input: string;
}

param0: {
password: string;
}

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

`Optional` keyCache?: boolean

`Optional` mode?: KeyUsage[]

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

`Optional` keyCache?: boolean

`Optional` mode?: KeyUsage[]

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

`Optional` keyCache?: boolean

`Optional` mode?: KeyUsage[]

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