Class API

new API(sdk: FilenSDK): API

v3(): {
    auth: () => {
        info: (...params: [{ email: string }]) => Promise<AuthInfoResponse>;
    };
    chat: () => {
        conversations: (...params: []) => Promise<ChatConversation[]>;
        conversationsCreate: (
            ...params: [{ metadata: string; ownerMetadata: string; uuid: string }],
        ) => Promise<void>;
        conversationsDelete: (...params: [{ uuid: string }]) => Promise<void>;
        conversationsLeave: (...params: [{ uuid: string }]) => Promise<void>;
        conversationsName: () => {
            edit: (...params: [{ name: string; uuid: string }]) => Promise<void>;
        };
        conversationsOnline: (
            ...params: [{ conversation: string }],
        ) => Promise<ChatConversationsOnlineResponse>;
        conversationsParticipants: () => {
            add: (
                ...params: [{ contactUUID: string; metadata: string; uuid: string }],
            ) => Promise<void>;
            remove: (...params: [{ userId: number; uuid: string }]) => Promise<void>;
        };
        conversationsRead: (...params: [{ uuid: string }]) => Promise<void>;
        conversationsUnread: (
            ...params: [{ uuid: string }],
        ) => Promise<ChatConversationsUnreadResponse>;
        delete: (...params: [{ uuid: string }]) => Promise<void>;
        edit: (
            ...params: [{ conversation: string; message: string; uuid: string }],
        ) => Promise<void>;
        lastFocus: (...params: []) => Promise<ChatLastFocusValues[]>;
        lastFocusUpdate: (
            ...params: [{ conversations: ChatLastFocusValues[] }],
        ) => Promise<void>;
        message: () => {
            embed: () => {
                disable: (...params: [{ uuid: string }]) => Promise<void>;
            };
        };
        messages: (
            ...params: [{ conversation: string; timestamp: number }],
        ) => Promise<ChatMessage[]>;
        send: (
            ...params: [
                {
                    conversation: string;
                    message: string;
                    replyTo: string;
                    uuid: string;
                },
            ],
        ) => Promise<void>;
        typing: (
            ...params: [{ conversation: string; type: ChatTypingType }],
        ) => Promise<void>;
        unread: (...params: []) => Promise<ChatUnreadResponse>;
    };
    confirmationSend: (...params: [{ email: string }]) => Promise<void>;
    contacts: () => {
        all: (...params: []) => Promise<ContactsResponse>;
        blocked: (...params: []) => Promise<ContactsBlockedResponse>;
        blockedAdd: (...params: [{ email: string }]) => Promise<void>;
        blockedDelete: (...params: [{ uuid: string }]) => Promise<void>;
        delete: (...params: [{ uuid: string }]) => Promise<void>;
        requestsAccept: (...params: [{ uuid: string }]) => Promise<void>;
        requestsDeny: (...params: [{ uuid: string }]) => Promise<void>;
        requestsIn: (...params: []) => Promise<ContactsRequestsInResponse>;
        requestsInCount: (...params: []) => Promise<number>;
        requestsOut: (...params: []) => Promise<ContactsRequestsOutResponse>;
        requestsOutDelete: (...params: [{ uuid: string }]) => Promise<void>;
        requestsSend: (...params: [{ email: string }]) => Promise<void>;
    };
    dir: () => {
        color: (...params: [{ color: string; uuid: string }]) => Promise<void>;
        content: (
            ...params: [{ dirsOnly?: boolean; uuid: string }],
        ) => Promise<DirContentResponse>;
        create: (
            ...params: [
                {
                    metadataEncrypted: string;
                    nameHashed: string;
                    parent: string;
                    uuid?: string;
                },
            ],
        ) => Promise<DirCreateResponse>;
        delete: () => {
            permanent: (...params: [{ uuid: string }]) => Promise<void>;
        };
        download: (
            ...params: [
                {
                    linkHasPassword?: boolean;
                    linkPassword?: string;
                    linkSalt?: string;
                    linkUUID?: string;
                    skipCache?: boolean;
                    type?: DirDownloadType;
                    uuid: string;
                },
            ],
        ) => Promise<DirDownloadResponse>;
        exists: (
            ...params: [{ nameHashed: string; parent: string }],
        ) => Promise<DirExistsResponse>;
        get: (...params: [{ uuid: string }]) => Promise<DirGetResponse>;
        link: () => {
            add: (
                ...params: [
                    {
                        expiration: string;
                        key: string;
                        linkUUID: string;
                        metadata: string;
                        parent: string;
                        type: string;
                        uuid: string;
                    },
                ],
            ) => Promise<void>;
            content: (
                ...params: [{ parent: string; password: string; uuid: string }],
            ) => Promise<DirLinkContentResponse>;
            edit: (
                ...params: [
                    {
                        downloadBtn: boolean;
                        expiration: PublicLinkExpiration;
                        password: string;
                        passwordHashed: string;
                        salt: string;
                        uuid: string;
                    },
                ],
            ) => Promise<void>;
            info: (...params: [{ uuid: string }]) => Promise<DirLinkInfoResponse>;
            remove: (...params: [{ uuid: string }]) => Promise<void>;
            status: (...params: [{ uuid: string }]) => Promise<DirLinkStatusResponse>;
        };
        linked: (...params: [{ uuid: string }]) => Promise<DirLinkedResponse>;
        metadata: (
            ...params: [
                { metadataEncrypted: string; nameHashed: string; uuid: string },
            ],
        ) => Promise<void>;
        move: (...params: [{ to: string; uuid: string }]) => Promise<void>;
        present: (...params: [{ uuid: string }]) => Promise<DirPresentResponse>;
        rename: (
            ...params: [
                { metadataEncrypted: string; nameHashed: string; uuid: string },
            ],
        ) => Promise<void>;
        restore: (...params: [{ uuid: string }]) => Promise<void>;
        shared: (...params: [{ uuid: string }]) => Promise<DirSharedResponse>;
        size: (
            ...params: [
                {
                    receiverId?: number;
                    sharerId?: number;
                    trash?: boolean;
                    uuid: string;
                },
            ],
        ) => Promise<DirSizeResponse>;
        sizeLink: (
            ...params: [{ linkUUID: string; uuid: string }],
        ) => Promise<DirSizeLinkResponse>;
        trash: (...params: [{ uuid: string }]) => Promise<void>;
        tree: (
            ...params: [
                {
                    deviceId: string;
                    includeRaw?: boolean;
                    skipCache?: boolean;
                    uuid: string;
                },
            ],
        ) => Promise<DirTreeResponse>;
    };
    file: () => {
        delete: () => {
            permanent: (...params: [{ uuid: string }]) => Promise<void>;
        };
        download: () => {
            chunk: () => {
                buffer: (
                    ...params: [
                        {
                            abortSignal?: (...)
                            | (...);
                            bucket: string;
                            chunk: number;
                            onProgress?: (...) | (...);
                            onProgressId?: (...) | (...);
                            region: string;
                            timeout?: (...) | (...);
                            uuid: string;
                        },
                    ],
                ) => Promise<Buffer>;
                local: (
                    ...params: [
                        {
                            abortSignal?: (...)
                            | (...);
                            bucket: string;
                            chunk: number;
                            onProgress?: (...) | (...);
                            onProgressId?: (...) | (...);
                            region: string;
                            timeout?: (...) | (...);
                            to: string;
                            uuid: string;
                        },
                    ],
                ) => Promise<void>;
                stream: (
                    ...params: [
                        {
                            abortSignal?: (...)
                            | (...);
                            bucket: string;
                            chunk: number;
                            onProgress?: (...) | (...);
                            onProgressId?: (...) | (...);
                            region: string;
                            timeout?: (...) | (...);
                            uuid: string;
                        },
                    ],
                ) => Promise<ReadableStream<(...)> | ReadStream>;
            };
        };
        exists: (
            ...params: [{ nameHashed: string; parent: string }],
        ) => Promise<FileExistsResponse>;
        get: (...params: [{ uuid: string }]) => Promise<FileGetResponse>;
        link: () => {
            edit: (
                ...params: [
                    {
                        downloadBtn: boolean;
                        expiration: PublicLinkExpiration;
                        fileUUID: string;
                        password: string;
                        passwordHashed: string;
                        salt: string;
                        type: "enable"
                        | "disable";
                        uuid: string;
                    },
                ],
            ) => Promise<void>;
            info: (
                ...params: [{ password: string; uuid: string }],
            ) => Promise<FileLinkInfoResponse>;
            password: (
                ...params: [{ uuid: string }],
            ) => Promise<FileLinkPasswordResponse>;
            status: (
                ...params: [{ uuid: string }],
            ) => Promise<FileLinkStatusResponse>;
        };
        metadata: (
            ...params: [
                {
                    metadataEncrypted: string;
                    nameEncrypted: string;
                    nameHashed: string;
                    uuid: string;
                },
            ],
        ) => Promise<void>;
        move: (...params: [{ to: string; uuid: string }]) => Promise<void>;
        present: (...params: [{ uuid: string }]) => Promise<FilePresentResponse>;
        rename: (
            ...params: [
                {
                    metadataEncrypted: string;
                    nameEncrypted: string;
                    nameHashed: string;
                    uuid: string;
                },
            ],
        ) => Promise<void>;
        restore: (...params: [{ uuid: string }]) => Promise<void>;
        trash: (...params: [{ uuid: string }]) => Promise<void>;
        upload: () => {
            chunk: () => {
                buffer: (
                    ...params: [
                        {
                            abortSignal?: (...)
                            | (...);
                            buffer: Buffer;
                            index: number;
                            maxRetries?: (...) | (...);
                            onProgress?: (...) | (...);
                            onProgressId?: (...) | (...);
                            parent: string;
                            retryTimeout?: (...) | (...);
                            timeout?: (...) | (...);
                            uploadKey: string;
                            uuid: string;
                        },
                    ],
                ) => Promise<UploadChunkResponse>;
            };
        };
        version: () => {
            restore: (
                ...params: [{ currentUUID: string; uuid: string }],
            ) => Promise<void>;
        };
        versions: (...params: [{ uuid: string }]) => Promise<FileVersionsResponse>;
    };
    health: () => Promise<"OK">;
    item: () => {
        favorite: (
            ...params: [
                { favorite: boolean; type: "file"
                | "folder"; uuid: string },
            ],
        ) => Promise<void>;
        linked: (...params: [{ uuid: string }]) => Promise<ItemLinkedResponse>;
        linkedRename: (
            ...params: [{ linkUUID: string; metadata: string; uuid: string }],
        ) => Promise<void>;
        share: (
            ...params: [
                {
                    email: string;
                    metadata: string;
                    parent: string;
                    type: "file"
                    | "folder";
                    uuid: string;
                },
            ],
        ) => Promise<void>;
        shared: (...params: [{ uuid: string }]) => Promise<ItemSharedResponse>;
        sharedIn: () => {
            remove: (...params: [{ uuid: string }]) => Promise<void>;
        };
        sharedOut: () => {
            remove: (
                ...params: [{ receiverId: number; uuid: string }],
            ) => Promise<void>;
        };
        sharedRename: (
            ...params: [{ metadata: string; receiverId: number; uuid: string }],
        ) => Promise<void>;
    };
    login: (
        ...params: [
            {
                authVersion: AuthVersion;
                email: string;
                password: string;
                twoFactorCode?: string;
            },
        ],
    ) => Promise<LoginResponse>;
    notes: () => {
        all: (...params: []) => Promise<NotesResponse>;
        archive: (...params: [{ uuid: string }]) => Promise<void>;
        content: (...params: [{ uuid: string }]) => Promise<NoteContent>;
        contentEdit: (
            ...params: [
                { content: string; preview: string; type: NoteType; uuid: string },
            ],
        ) => Promise<void>;
        create: (
            ...params: [{ metadata: string; title: string; uuid: string }],
        ) => Promise<void>;
        delete: (...params: [{ uuid: string }]) => Promise<void>;
        favorite: (
            ...params: [{ favorite: boolean; uuid: string }],
        ) => Promise<void>;
        history: (...params: [{ uuid: string }]) => Promise<NotesHistoryResponse>;
        historyRestore: (
            ...params: [{ id: number; uuid: string }],
        ) => Promise<void>;
        participantsAdd: (
            ...params: [
                {
                    contactUUID: string;
                    metadata: string;
                    permissionsWrite: boolean;
                    uuid: string;
                },
            ],
        ) => Promise<void>;
        participantsPermissions: (
            ...params: [
                { permissionsWrite: boolean; userId: number; uuid: string },
            ],
        ) => Promise<void>;
        participantsRemove: (
            ...params: [{ userId: number; uuid: string }],
        ) => Promise<void>;
        pinned: (...params: [{ pinned: boolean; uuid: string }]) => Promise<void>;
        restore: (...params: [{ uuid: string }]) => Promise<void>;
        tag: (...params: [{ tag: string; uuid: string }]) => Promise<void>;
        tags: (...params: []) => Promise<NotesTagsResponse>;
        tagsCreate: (
            ...params: [{ name: string }],
        ) => Promise<NotesTagsCreateResponse>;
        tagsDelete: (...params: [{ uuid: string }]) => Promise<void>;
        tagsFavorite: (
            ...params: [{ favorite: boolean; uuid: string }],
        ) => Promise<void>;
        tagsRename: (...params: [{ name: string; uuid: string }]) => Promise<void>;
        titleEdit: (...params: [{ title: string; uuid: string }]) => Promise<void>;
        trash: (...params: [{ uuid: string }]) => Promise<void>;
        typeChange: (
            ...params: [
                { content: string; preview: string; type: NoteType; uuid: string },
            ],
        ) => Promise<void>;
        untag: (...params: [{ tag: string; uuid: string }]) => Promise<void>;
    };
    register: (
        ...params: [
            {
                affId?: string;
                authVersion: AuthVersion;
                email: string;
                password: string;
                refId?: string;
                salt: string;
            },
        ],
    ) => Promise<void>;
    search: () => {
        add: (
            ...params: [{ items: SearchAddItem[] }],
        ) => Promise<SearchAddResponse>;
        find: (...params: [{ hashes: string[] }]) => Promise<SearchFindResponse>;
    };
    shared: () => {
        in: (
            ...params: [params?: { uuid?: string }],
        ) => Promise<SharedInResponse>;
        out: (
            ...params: [params?: { receiverId?: number; uuid?: string }],
        ) => Promise<SharedOutResponse>;
    };
    trash: () => { empty: (...params: []) => Promise<void> };
    upload: () => {
        done: (
            ...params: [
                {
                    chunks: number;
                    metadata: string;
                    mime: string;
                    name: string;
                    nameHashed: string;
                    rm: string;
                    size: string;
                    uploadKey: string;
                    uuid: string;
                    version: FileEncryptionVersion;
                },
            ],
        ) => Promise<UploadDoneResponse>;
        empty: (
            ...params: [
                {
                    metadata: string;
                    mime: string;
                    name: string;
                    nameHashed: string;
                    parent: string;
                    size: string;
                    uuid: string;
                    version: FileEncryptionVersion;
                },
            ],
        ) => Promise<UploadEmptyResponse>;
    };
    user: () => {
        account: (...params: []) => Promise<UserAccountResponse>;
        affiliate: () => {
            payout: (
                ...params: [{ address: string; method: string }],
            ) => Promise<void>;
        };
        appearOffline: (...params: [{ appearOffline: boolean }]) => Promise<void>;
        avatar: (...params: [{ base64: string; hash: string }]) => Promise<void>;
        baseFolder: (
            ...params: [{ apiKey?: string }],
        ) => Promise<UserBaseFolderResponse>;
        delete: (...params: [{ twoFactorCode?: string }]) => Promise<void>;
        deleteAll: (...params: []) => Promise<void>;
        deleteVersions: (...params: []) => Promise<void>;
        didExportMasterKeys: (...params: []) => Promise<void>;
        event: (...params: [{ uuid: string }]) => Promise<UserEvent>;
        events: (
            ...params: [{ filter: string; lastTimestamp: number }],
        ) => Promise<UserEvent[]>;
        gdpr: (...params: []) => Promise<UserGDPRResponse>;
        getDEK: (
            ...params: [params?: { apiKey?: string }],
        ) => Promise<UserGetDEKResponse>;
        info: (...params: [{ apiKey?: string }]) => Promise<UserInfoResponse>;
        invoice: (...params: [{ uuid: string }]) => Promise<string>;
        keyPair: () => {
            info: (
                ...params: [{ apiKey?: string }],
            ) => Promise<UserKeyPairInfoResponse>;
            set: (
                ...params: [
                    { apiKey?: string; encryptedPrivateKey: string; publicKey: string },
                ],
            ) => Promise<void>;
            update: (
                ...params: [
                    { apiKey?: string; encryptedPrivateKey: string; publicKey: string },
                ],
            ) => Promise<void>;
        };
        lastActive: () => {
            desktop: (...params: [{ timestamp: number }]) => Promise<void>;
        };
        lock: (
            ...params: [
                {
                    resource: string;
                    type: "acquire"
                    | "refresh"
                    | "status"
                    | "release";
                    uuid: string;
                },
            ],
        ) => Promise<UserLockResponse>;
        loginAlerts: (...params: [{ enable: boolean }]) => Promise<void>;
        masterKeys: (
            ...params: [{ apiKey?: string; encryptedMasterKeys: string }],
        ) => Promise<UserMasterKeysResponse>;
        nickname: (...params: [{ nickname: string }]) => Promise<void>;
        password: () => {
            forgot: (...params: [{ email: string }]) => Promise<void>;
            forgotReset: (
                ...params: [
                    {
                        authVersion: number;
                        hasRecoveryKeys: boolean;
                        newMasterKeys: string;
                        password: string;
                        salt: string;
                        token: string;
                    },
                ],
            ) => Promise<void>;
        };
        personal: () => {
            change: (
                ...params: [
                    {
                        city: string;
                        companyName: string;
                        country: string;
                        firstName: string;
                        lastName: string;
                        postalCode: string;
                        street: string;
                        streetNumber: string;
                        vatId: string;
                    },
                ],
            ) => Promise<void>;
        };
        profile: (...params: [{ id: number }]) => Promise<UserProfileResponse>;
        publicKey: (
            ...params: [{ email: string }],
        ) => Promise<UserPublicKeyResponse>;
        setDEK: (
            ...params: [{ apiKey?: string; encryptedDEK: string }],
        ) => Promise<void>;
        settings: (...params: []) => Promise<UserSettingsResponse>;
        settingsEmail: () => {
            change: (
                ...params: [
                    { authVersion: AuthVersion; email: string; password: string },
                ],
            ) => Promise<void>;
        };
        settingsPassword: () => {
            change: (
                ...params: [
                    {
                        authVersion: AuthVersion;
                        currentPassword: string;
                        masterKeys: string;
                        password: string;
                        salt: string;
                    },
                ],
            ) => Promise<UserSettingsPasswordChangeResponse>;
        };
        sub: () => {
            cancel: (...params: [{ uuid: string }]) => Promise<void>;
            create: (
                ...params: [{ method: PaymentMethods; planId: number }],
            ) => Promise<UserSubCreateResponse>;
        };
        twoFactorAuthentication: () => {
            disable: (...params: [{ code: string }]) => Promise<void>;
            enable: (...params: [{ code: string }]) => Promise<User2FAEnableResponse>;
        };
        versioning: (...params: [{ enable: boolean }]) => Promise<void>;
    };
}