nb-js-client 0.0.34 → 0.0.35

package/dist/index.d.ts

@@ -0,0 +1,1313 @@
+interface StorageElement {
+    name: string;
+    size: number;
+    shared: boolean;
+    full_path: string;
+    path: string;
+    type: StorageElementType;
+    file_name_ext: string;
+    content_type: StorageElementContentType;
+    update_date: string;
+    create_date: string;
+    with_preview: boolean;
+    is_favorite: boolean;
+    owner_id: number;
+    version?: StorageElementVersion;
+    divide_id?: number;
+    access_mode?: PermissionType;
+    to_user_group_id?: number;
+    created_by_extension?: string;
+    check_status?: StorageElementCheckStatus;
+}
+declare enum StorageElementType {
+    Dir = "dir",
+    File = "file",
+    WorkDir = "work_dir"
+}
+declare enum StorageElementContentType {
+    Any = "any",
+    Dir = "dir",
+    Code = "code",
+    Image = "image",
+    Audio = "audio",
+    Video = "video",
+    Text = "text",
+    Doc = "doc",
+    Xls = "xls",
+    Ppt = "ppt"
+}
+declare enum StorageRoot {
+    my = "my",
+    fca = "fca",
+    divide = "divide",
+    share = "share",
+    favorite = "favorite"
+}
+interface StorageRouteData {
+    path: string;
+    root: StorageRoot;
+    rootId: number;
+    divideDir?: string;
+    share_token?: string;
+    share_password?: string;
+    share_back?: boolean;
+    dash_back?: boolean;
+    access_mode?: PermissionType;
+    file_version_id?: string;
+}
+interface StorageElementPaste {
+    from_path: string;
+    to_path: string;
+}
+interface StorageElementHistory {
+    user_id: number;
+    action: StorageElementHistoryAction;
+    create_date: string;
+}
+interface StorageElementVersion {
+    id: string;
+    size: number;
+    user_id: number;
+    name: string;
+    description: string;
+    create_date: string;
+    update_date: string;
+    is_current_version: boolean;
+}
+declare enum StorageElementHistoryAction {
+    Create = "create",
+    Update = "update",
+    Move = "move"
+}
+interface HistoryNote {
+    name: string;
+    description: string;
+    divide_id: number | null;
+    file_version_id: string;
+    path: string;
+}
+declare enum StorageElementCheckStatus {
+    CheckNull = 0,
+    CheckInProgress = 1,
+    CheckPositive = 2,
+    CheckNegative = 3
+}
+interface RequestVersionsSizeParams {
+    path: string;
+    divide_id?: number;
+}
+interface StorageInstance {
+    disk_id: string;
+    disk_size: number;
+    free_size: number;
+    instance_number: number;
+    quota_size_config: number;
+    quota_size_setting: number;
+    used_size: number;
+}
+interface SizeBySection {
+    content_type: string;
+    size: number;
+    count: number;
+    label: string;
+}
+
+declare enum DivideScope {
+    Storage = "/storage/element",
+    Connection = "/connections"
+}
+type DivideResourceType = string | number;
+declare enum PermissionType {
+    CLOSE = "",
+    READ = "r",
+    WRITE = "rw"
+}
+declare enum RestrictionStatus {
+    WAITING = "waiting",
+    APPROVED = "approved",
+    REJECTED = "rejected"
+}
+declare enum RestrictionBooleanStatus {
+    TRUE = "true",
+    FALSE = "false"
+}
+declare enum DivideMode {
+    User = "to_user_id",
+    Group = "to_user_group_id"
+}
+interface ShareInfo extends DivideParams {
+    id: number;
+    token: string;
+    access_mode: PermissionType;
+    expire_delta: number | null;
+    expire_in?: string;
+    with_password: boolean;
+    share_sub_type: StorageElementType;
+    create_date: string;
+    update_date: string;
+    owner_id: number;
+    resource: string;
+    file_info: StorageElement;
+    short_url: string;
+}
+interface UnionRestriction extends UserDivide, ShareInfo {
+}
+interface UserDivide extends DivideParams {
+    access_mode: PermissionType;
+    create_date: string;
+    id: number;
+    name: string;
+    owner_id: number;
+    resource: string;
+    to_user_group_id: number;
+    to_user_id: number;
+    type: StorageElementType;
+    update_date: string;
+    file_info: StorageElement;
+}
+declare enum RestrictionModeKey {
+    Divide = "divide",
+    Share = "share"
+}
+interface DivideParams {
+    restriction_status: RestrictionStatus;
+    moderator_id?: number;
+    comment: string;
+}
+interface RequestUserDivideParams {
+    is_to_user_group: boolean;
+    access_mode?: PermissionType;
+    limit?: number;
+    offset?: number;
+    search_field?: string;
+}
+type DivideResponseList = ResponseList<UserDivide> & {
+    total_r: number;
+    total_rw: number;
+};
+interface ShareModel {
+    token: string;
+    access_mode: PermissionType;
+    password: string | null;
+    expire_delta: number | null;
+}
+
+interface NbClientParams {
+    host?: string;
+    version?: string;
+}
+interface NbRequestParams {
+    path: string;
+    headers?: Record<string, any>;
+    query?: Record<string, any>;
+    body?: any;
+    cache?: RequestCache;
+}
+interface NbAppState {
+    clientParams: NbClientParams;
+    requestParams: NbRequestParams;
+    authToken: Map<number, RequestAuthTokenParams> | null;
+    skipInterceptors: boolean;
+}
+interface ResponseItem<T> {
+    row: T;
+}
+interface ResponseList<T> {
+    rows: T[];
+    total: number;
+    current?: {
+        access_mode: PermissionType;
+    };
+}
+interface RequestBaseParams {
+    limit: number;
+    offset?: number;
+    order_by?: string;
+    order_direction?: OrderDirection;
+}
+declare enum OrderDirection {
+    DEFAULT = "",
+    ASC = "asc",
+    DESC = "desc"
+}
+type Lang = {
+    [key: string]: string;
+};
+declare enum EngineType {
+    WebSocket = "websocket",
+    PostMessage = "postmessage",
+    Empty = ""
+}
+
+type Interceptor<T = any> = {
+    fulfilled: (value: T) => T | Promise<T>;
+    rejected: (error: any) => any;
+};
+
+declare class TokenUpdate {
+    private authApiService;
+    isUpdating: boolean;
+    private tokenUpdateResolve;
+    constructor(authApiService: AuthApiService);
+    isTokenExpire(timestamp: number): boolean;
+    refreshToken(params: RequestAuthTokenParams): Promise<any>;
+    waitForTokenUpdate(): Promise<void>;
+}
+
+declare class Client {
+    state: NbAppState;
+    AuthApiService: AuthApiService;
+    ConnectionsApiService: ConnectionsApiService;
+    DiscoveryApiService: DiscoveryApiService;
+    DivideApiService: DivideApiService;
+    ExtensionsApiService: ExtensionsApiService;
+    ExtensionsExternalApiService: ExtensionsExternalApiService;
+    FcaApiService: FcaApiService;
+    GatewayApiService: GatewayApiService;
+    GroupApiService: GroupApiService;
+    LicenseApiService: LicenseApiService;
+    LinksApiService: LinksApiService;
+    LogstashApiService: LogstashApiService;
+    NotificationApiService: NotificationApiService;
+    RoleApiService: RoleApiService;
+    ShareApiService: ShareApiService;
+    StorageElementApiService: StorageElementApiService;
+    StorageFilesApiService: StorageFilesApiService;
+    StorageInstanceApiService: StorageInstanceApiService;
+    StorageShareApiService: StorageShareApiService;
+    StorageTrashApiService: StorageTrashApiService;
+    UserApiService: UserApiService;
+    VersionApiService: VersionApiService;
+    tokenUpdate: TokenUpdate;
+    rest: Rest;
+    requestInterceptors: Interceptor<RequestInit>[];
+    responseInterceptors: Interceptor<any>[];
+    constructor(clientParams: NbClientParams);
+    request: {
+        use: (fulfilled: (config: RequestInit) => RequestInit | Promise<RequestInit>, rejected: (error: any) => any) => void;
+    };
+    response: {
+        use: (fulfilled: (response: any) => any | Promise<any>, rejected: (error: any) => any) => void;
+    };
+}
+
+declare enum AccessRights {
+    LicenseRead = "license_read",// Просмотр
+    LicenseManage = "license_edit",// Управление лицензией
+    UsersRead = "users_read",// Просмотр
+    UsersCreate = "users_create",// Создание/редактирование
+    UsersActivate = "users_activate",// Активация/деактивация
+    GroupsRead = "groups_read",// Просмотр
+    GroupsCreate = "groups_create",// Создание/редактирование
+    RolesRead = "roles_read",// Просмотр списка
+    RolesCreate = "roles_create",// Создание/редактирование
+    Share = "share",// Шаринг доступа по ссылке
+    Divide = "divide",// Предоставление доступа
+    ExtensionsRead = "extensions_read",// Просмотр
+    ExtensionsManage = "extensions_write",// Управление расширениями
+    RestrictionShareRead = "restriction_share_read",// Просмотр
+    RestrictionShareWrite = "restriction_share_write",// Управление шарингом
+    RestrictionDivideRead = "restriction_divide_read",// Просмотр
+    RestrictionDivideWrite = "restriction_divide_write",// Управление доступами
+    ReadUserLogs = "read_user_logs",// Просмотр пользовательских логов
+    ReadSystemLogs = "read_system_logs",// Просмотр системных логов
+    ConnectionsRead = "connections_read",// Просмотр
+    ConnectionsDividing = "connections_dividing",// Предоставление доступа(поделиться)
+    ConnectionsYandexDisk = "connections_yandex_disk",// Yandex диск
+    ConnectionsSsh = "connections_ssh",// Ssh
+    ConnectionsMail = "connections_mail",// Почта
+    ConnectionsS3 = "connections_s3",// S3
+    ConnectionsDiscord = "connections_discord",// Discord
+    ConnectionsWebdav = "connections_webdav",// Webdav
+    ConnectionsNextcloud = "connections_nextcloud",// Nextcloud
+    ConnectionsNextbox = "connections_nextbox",// Nextbox
+    ConnectionsHttpProxy = "connections_http_proxy",// Http proxy
+    SystemInfoServiceList = "system_info_service_list",// Просмотр
+    SettingsRead = "settings_read",// Просмотр
+    SettingsWrite = "settings_write"
+}
+declare const CONNECTIONS_PERMISSION: AccessRights[];
+
+interface User {
+    id: number;
+    create_date: string;
+    update_date: string;
+    last_login_date: string;
+    login: string;
+    password: string;
+    first_name: string;
+    middle_name: string;
+    last_name: string;
+    email: string;
+    auth_type: UserAuthType;
+    avatar_path: string;
+    home_path: string;
+    status: UserStatus;
+    type: UserType;
+    role_id: number | null;
+}
+type UserLabel = Pick<User, 'login' | 'email' | 'first_name' | 'middle_name' | 'last_name' | 'avatar_path'>;
+declare enum UserAuthType {
+    Native = "native",
+    Ldap = "ldap",
+    Vk = "vk"
+}
+declare enum UserStatus {
+    Registering = "registering",
+    Activated = "activated",
+    Blocked = "blocked",
+    BlockedByLicense = "blocked_by_license"
+}
+declare enum UserType {
+    User = "user",
+    Guest = "guest",
+    Emperor = "emperor",
+    Anonymous = "anonymous"
+}
+interface UserSession {
+    create_date: string;
+    expire_in: string;
+    ip: string;
+    user_agent: string;
+    id: number;
+    is_current?: boolean;
+}
+interface UserToken {
+    id: number;
+    name: string;
+    expire_in: string;
+    create_date: string;
+    token?: string;
+}
+interface UserGroup {
+    id: number;
+    name: string;
+    description: string;
+    amount_users: number;
+    create_date: string;
+    owner_id: number;
+    owner: UserLabel;
+    update_date: string;
+    icon: string;
+    icon_color: string;
+}
+interface UserRole {
+    id: number;
+    name: string;
+    description: string;
+    create_date: string;
+    update_date: string;
+    is_default: boolean;
+    owner_id: number;
+    grant_access_all: boolean;
+    permissions_id?: number[];
+}
+
+interface AccessToken {
+    exp: number;
+    iat: number;
+    login: string;
+    user_id: number;
+    is_remember: boolean;
+    with_cookie: boolean;
+    grant_access_all: boolean;
+    user_type: UserType;
+    permissions: {
+        [key: string]: AccessRights[];
+    };
+}
+
+interface AuthToken {
+    access_token: string;
+    refresh_token: string;
+}
+interface AuthType {
+    classic: boolean;
+    basic: boolean;
+    ldap: boolean;
+}
+
+interface Connection {
+    id: number;
+    name: string;
+    type: ConnectionType;
+    address: string;
+    login: string;
+    password: string;
+    port: number;
+    root_path: string;
+    group_name: ConnectionGroup;
+    owner_id: number;
+    divide_id?: number;
+    access_mode?: PermissionType;
+    update_date: string;
+    create_date: string;
+    expire_in: string;
+    to_user_group_id?: number;
+}
+declare enum ConnectionGroup {
+    Storages = "storages_connections_group",
+    Webhooks = "webhooks_connections_group",
+    Unknown = "unknown_connections_group",
+    Proxy = "proxy_connections_group"
+}
+declare enum ConnectionType {
+    SSH = "ssh_connection",
+    YandexDisk = "yandex_disk",
+    Mail = "mail",
+    Discord = "discord",
+    Webdav = "webdav_connection",
+    Nextcloud = "nextcloud_connection",
+    NextBox = "nextbox_connection",
+    HttpProxy = "http_proxy_connection",
+    S3 = "s3_connection"
+}
+
+interface Discovery {
+    id: number;
+    create_date: string;
+    update_date: string;
+    active: boolean;
+    back_url: string;
+    front_url: string;
+    instance_number: number;
+    name: string;
+    route: null;
+    route_name: string;
+    with_swagger: boolean;
+    dynamic_config_path?: string;
+    version: string;
+}
+
+type SettingLang = string | Lang | null;
+declare enum SettingControlType {
+    Text = "text",
+    String = "string",
+    Number = "number",
+    CheckBox = "checkbox",
+    Select = "select",
+    RadioList = "radio_list",
+    ConnectionChoose = "connection_choose",
+    MultiConnectionChoose = "multi_connection_choose"
+}
+interface Setting {
+    fields: SettingField[];
+    title?: SettingLang;
+    name?: string;
+    context?: string;
+    toggle_box?: boolean;
+    collapsed_box?: boolean;
+    activity_switch?: boolean;
+}
+interface SettingVariant {
+    label?: SettingLang;
+    value: any;
+}
+interface SettingField {
+    name: string;
+    value: any;
+    label?: SettingLang;
+    help?: SettingLang;
+    placeholder?: SettingLang;
+    view?: SettingFieldView;
+    disabled?: boolean;
+    control: {
+        type: SettingControlType;
+        filter?: Record<string, any>;
+        variants?: SettingVariant[];
+    };
+}
+type SettingFieldView = SettingViewConnectionChoose | SettingViewSelect | any;
+interface SettingViewConnectionChoose {
+    id: number;
+    name: string;
+    owner_id: number;
+}
+interface SettingViewSelect {
+    show_clear?: boolean;
+}
+interface SettingValueField {
+    name: string;
+    value: any;
+}
+interface SettingValue {
+    name: string;
+    context?: string;
+    fields: SettingValueField[];
+    activity_switch?: boolean;
+}
+
+interface ExtensionDefault {
+    ext_value: string;
+    extension_meta_uniq_key: string;
+    icon_path: string;
+    devlocal?: boolean;
+}
+declare enum ExtensionType {
+    App = "app",
+    File = "file",
+    WorkDir = "work_dir"
+}
+declare enum ExtensionFileMode {
+    Read = "read",
+    ReadAndWrite = "read_and_write",
+    Write = "write"
+}
+interface Extension {
+    id: number;
+    create_date: string;
+    update_date: string;
+    with_settings?: boolean;
+    name: Lang;
+    devlocal?: boolean;
+    dev_frame_params?: {
+        engine: EngineType;
+        host?: string;
+        port?: number;
+    };
+    version: string;
+    latest_repo_version?: string;
+    description: Lang;
+    uniq_key: string;
+    icon: string;
+    type: ExtensionType;
+    path: string;
+    file?: {
+        mode: ExtensionFileMode;
+        ext: string[];
+        default_ext?: string;
+        index: string;
+    };
+    app?: {
+        menu: {
+            index: string;
+            icon: string;
+            label: Lang;
+        };
+    };
+    work_dir?: {
+        index: string;
+    };
+    settings?: SettingValue[];
+    settings_template?: Setting[];
+}
+interface ExtensionMetaPayload {
+    uniq_key: string;
+}
+interface ExtensionExternalInList {
+    id: number;
+    create_date: string;
+    update_date: string;
+    name: string;
+    description: string;
+    uniq_key: string;
+    version: string;
+    tags: string[];
+    links: string[];
+}
+interface ExtensionExternal extends ExtensionExternalInList {
+    versions: VersionExtension[];
+    images?: string[];
+    with_readme?: boolean;
+}
+interface VersionExtension {
+    version: string;
+    size: number;
+}
+
+interface License {
+    custom_max_users_count: number | null;
+    expire_in: string;
+    key: string | null;
+    plan: Tariff;
+    error?: LicenseError | string;
+}
+interface ChangeLicenseParams {
+    key: string;
+    domain: string;
+}
+declare enum Tariff {
+    Free = "free",
+    Business = "business",
+    Enterprise = "enterprise"
+}
+declare enum LicenseError {
+    NotActivated = "License not activated",
+    Blocked = "License blocked",
+    Expired = "License has been expired",
+    NotValid = "License not valid",
+    NotFound = "license file not found"
+}
+
+interface LockScreen {
+    enabled: boolean;
+    duration: number;
+}
+
+interface UserNotification {
+    id: number;
+    create_date: string;
+    update_date: string;
+    entity_type: NotificationEntityType;
+    action: NotificationAction;
+    title: string;
+    msg: string;
+    transition: boolean;
+    read: boolean;
+    style: NotificationStyle;
+    payload: NotificationPayload;
+    from_user_id?: number;
+    owner?: UserLabel;
+}
+declare enum NotificationEntityType {
+    Dir = "dir",
+    File = "file",
+    User = "user",
+    Other = "other",
+    WorkDir = "work_dir",
+    License = "license",
+    Extension = "extension",
+    Connection = "connection"
+}
+declare enum NotificationAction {
+    OpenSharing = "open_sharing",
+    ChangeSharing = "change_sharing",
+    CancelSharing = "cancel_sharing",
+    DivideDirAddFileToOwner = "divide_dir_add_file_to_owner",
+    DivideDirAddDirToOwner = "divide_dir_add_dir_to_owner",
+    DivideDirAddWorkDirToOwner = "divide_dir_add_work_dir_to_owner",
+    DivideConnectionAddFileToOwner = "divide_connection_add_file_to_owner",
+    DivideConnectionAddDirToOwner = "divide_connection_add_dir_to_owner",
+    CancelDivideDir = "cancel_divide_dir",
+    CancelDivideFile = "cancel_divide_file",
+    CancelDivideWorkDir = "cancel_divide_work_dir",
+    CancelDivideConnection = "cancel_divide_connection",
+    DeleteExtension = "delete_extension",
+    NewVersionExtension = "new_version_extension",
+    TransferData = "transfer_data",
+    AllowInternalAccessUser = "allow_internal_access_to_user",
+    BlockInternalAccessUser = "block_internal_access_to_user",
+    WaitInternalAccessUser = "wait_internal_access_to_user",
+    WaitInternalAccessUserCreate = "wait_internal_access_to_user_create",
+    AllowInternalAccessGroup = "allow_internal_access_to_group",
+    BlockInternalAccessGroup = "block_internal_access_to_group",
+    WaitInternalAccessGroup = "wait_internal_access_to_group",
+    WaitInternalAccessGroupCreate = "wait_internal_access_to_group_create",
+    AllowSharing = "allow_sharing",
+    BlockSharing = "block_sharing",
+    WaitSharing = "wait_sharing",
+    WaitSharingCreate = "wait_sharing_create",
+    Other = "other"
+}
+declare enum NotificationRowAction {
+    Read = "read",
+    Unread = "unread",
+    Delete = "delete"
+}
+declare enum NotificationStyle {
+    Plain = "plain",
+    Success = "success",
+    Info = "info",
+    Warning = "warning",
+    Error = "error"
+}
+type NotificationActionGroup = {
+    [key: string]: NotificationActionEnabledGroup;
+};
+interface NotificationActionEnabledGroup {
+    enabled_system: boolean;
+    enabled_mail: boolean;
+}
+type NotificationPayload = PayloadFile | any;
+interface PayloadFile {
+    access_mode: PermissionType;
+    create_date: string;
+    id: number;
+    name: string;
+    owner_id: number;
+    path: string;
+    to_user_id: number;
+    type: StorageElementType;
+    update_date: string;
+}
+
+interface Permission {
+    group_name: Lang;
+    permissions: PermissionItem[];
+}
+interface PermissionItem {
+    id: number;
+    priority: number;
+    title: Lang;
+}
+
+declare enum ResponseType {
+    ArrayBuffer = "arraybuffer",
+    Blob = "blob",
+    Json = "json",
+    Text = "text"
+}
+declare enum RequestMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
+}
+declare enum RequestObserve {
+    Body = "body",
+    Response = "response"
+}
+interface HttpResponse<T> {
+    status: number;
+    statusText: string;
+    headers: Headers;
+    body: T;
+}
+interface HttpEvent<T> {
+    loaded?: number;
+    total?: number;
+    body?: HttpResponse<T>;
+    error?: any;
+}
+interface RequestConfig {
+    params?: Record<string, string>;
+    body?: any;
+    cache?: RequestCache;
+    headers?: HeadersInit;
+    observe?: RequestObserve;
+    responseType?: ResponseType;
+    signal?: AbortSignal | null;
+    onUploadProgress?: OnUploadProgress;
+}
+interface ProgressEvent {
+    loaded: number;
+    total: number;
+}
+type OnUploadProgress = (progressEvent: ProgressEvent) => void;
+
+declare enum RestrictionSharing {
+    NONE = "none",
+    SOFT = "soft",
+    HARD = "hard"
+}
+interface Restriction {
+    sharing: RestrictionSharing;
+    divide: RestrictionSharing;
+}
+
+interface UsersLog {
+    create_date: string;
+    service_name: string;
+    user_login: string;
+    event_type: string;
+    action: string;
+    resource: string;
+    description: string;
+}
+
+interface StorageTrashElement {
+    content_type: StorageElementContentType;
+    del_group_id: number;
+    file_name_ext: string;
+    full_path: string;
+    name: string;
+    path: string;
+    size: number;
+    type: StorageElementType;
+    update_date: string;
+    version: VersionStorageTrashElement;
+    with_preview: boolean;
+}
+interface VersionStorageTrashElement {
+    create_date: string;
+    description: string;
+    id: string;
+    name: string | null;
+    size: number;
+    update_date: string;
+    user_id: number;
+}
+type StorageTrashItem = Pick<StorageTrashElement, 'del_group_id' | 'path'>;
+
+declare const BASE_URL_V1 = "/api/v1";
+declare const BASE_URL_V2 = "/api/v2";
+declare const HOST: string;
+declare class Rest {
+    private client;
+    private tokenUpdate;
+    constructor(client: Client, tokenUpdate: TokenUpdate);
+    get state(): NbAppState;
+    get(path: string, params?: Record<string, any>, config?: RequestConfig): Promise<any>;
+    post(path: string, body?: BodyInit | null, config?: RequestConfig): Promise<any>;
+    put(path: string, body?: BodyInit | null, config?: RequestConfig): Promise<any>;
+    patch(path: string, body?: BodyInit | null, config?: RequestConfig): Promise<any>;
+    delete(path: string, params?: Record<string, any>, config?: RequestConfig): Promise<any>;
+    upload(path: string, body?: BodyInit | null, config?: RequestConfig): {
+        promise: Promise<any>;
+        abort: () => void;
+    };
+    request<T>(method: RequestMethod, path: string, config?: RequestConfig): Promise<T | HttpResponse<T> | HttpEvent<T>>;
+    changeBaseUrlVersion<T>(baseUrl: string, handler: () => Promise<T>): Promise<T>;
+    changeHost<T>(host: string, handler: () => Promise<T>): Promise<T>;
+}
+
+declare class AuthApiService {
+    private client;
+    constructor(client: Client);
+    info(): Promise<AuthType>;
+    login(data: RequestAuthSettingsParams): Promise<AuthToken>;
+    ldapLogin(data: RequestAuthSettingsParams): Promise<AuthToken>;
+    updateToken(data: RequestAuthTokenParams): Promise<AuthToken>;
+    logout(): Promise<void>;
+}
+interface RequestAuthSettingsParams {
+    login: string;
+    password: string;
+    is_remember: boolean;
+}
+interface RequestAuthTokenParams extends AuthToken {
+    with_cookie?: boolean;
+    path?: string;
+}
+
+declare class ConnectionsApiService {
+    private client;
+    constructor(client: Client);
+    list(params: RequestConnectionParams): Promise<ResponseList<Connection>>;
+    get(id: number): Promise<ResponseItem<Connection>>;
+    update(id: number, data: ConnectionCreateParams): Promise<ResponseItem<Connection>>;
+    delete(id: number): Promise<void>;
+    create(data: ConnectionCreateParams): Promise<ResponseItem<Connection>>;
+    dashboard(params: RequestConnectionParams): Promise<ResponseList<Connection>>;
+}
+interface RequestConnectionParams extends RequestBaseParams {
+    id?: number[];
+    name?: string | null;
+    group_name?: ConnectionGroup;
+    is_divided?: boolean;
+    type?: string;
+}
+type ConnectionCreateParams = Omit<Connection, 'group_name'>;
+
+declare class DiscoveryApiService {
+    private client;
+    constructor(client: Client);
+    discovery(params?: any): Promise<ResponseList<Discovery>>;
+}
+
+declare class DivideApiService {
+    private client;
+    constructor(client: Client);
+    divideDelete(service: DivideScope, id: number): Promise<void>;
+    divideDeleteAll(service: DivideScope, resource: DivideResourceType, access_mode: PermissionType, is_to_user_group: boolean): Promise<void>;
+    divideChange(service: DivideScope, id: number, access_mode: PermissionType): Promise<UserDivide>;
+    divideCreate(service: DivideScope, resource: DivideResourceType, id: number, access_mode: PermissionType, key: DivideMode): Promise<ResponseItem<UserDivide>>;
+    divideUsers(service: DivideScope, resource: DivideResourceType, params: RequestUserDivideParams): Promise<DivideResponseList>;
+    getRestriction(id: number): Promise<UnionRestriction>;
+    restrictionSize(key: string | number, modeKey: RestrictionModeKey): Promise<number>;
+    restrictions(params?: any): Promise<ResponseList<UserDivide>>;
+    restrictionsChange(token: number, data: {
+        status: any;
+        comment: string;
+    }): Promise<ResponseList<UserDivide>>;
+    private makeParam;
+}
+
+declare class ExtensionsApiService {
+    private client;
+    constructor(client: Client);
+    getSetting(uniqKey: string): Promise<SettingValue[]>;
+    setSetting(uniqKey: string, params: SettingValue[]): Promise<void>;
+    deleteSetting(uniqKey: string): Promise<void>;
+    get(id: number): Promise<ResponseItem<Extension>>;
+    getByKey(uniqKey: string): Promise<ResponseItem<Extension | null>>;
+    getDefault(ext_code?: string[]): Promise<ResponseList<ExtensionDefault>>;
+    setDefault(ext_code: string, ext_uniq_key: string): Promise<ExtensionDefault>;
+    checkUpdates(): Promise<void>;
+    updateVersion(id: number, version: string): Promise<Extension>;
+    list(params?: ExtensionListParams): Promise<ResponseList<Extension & {
+        with_settings: boolean;
+    }>>;
+    delete(id: number, name: string): Promise<void>;
+    upload(onProgress: OnUploadProgress, file: File): {
+        promise: Promise<HttpEvent<ResponseItem<Extension>>>;
+        abort: () => void;
+    };
+    install(uniq_key: string, version: string): Promise<any>;
+}
+interface ExtensionListParams extends RequestBaseParams {
+    search?: string | null;
+    uniq_key?: string[];
+    file_name_ext?: string;
+    type?: StorageElementType[];
+    ext_value?: string | null;
+    file_mode?: ExtensionFileMode[];
+    lang?: string;
+}
+
+declare class ExtensionsExternalApiService {
+    private client;
+    constructor(client: Client);
+    listExtensionsSite(params: ExtensionExternalListParams): Promise<ResponseList<ExtensionExternalInList>>;
+    extensionDetailSite(uniqKey: string): Promise<ExtensionExternal>;
+    extensionMarkdown(uniqKey: string, config: {
+        responseType: ResponseType;
+    }): Promise<string>;
+}
+interface ExtensionExternalListParams extends RequestBaseParams {
+    search_field?: string;
+}
+
+declare class StorageElementApiService {
+    private client;
+    private fcaApiService;
+    constructor(client: Client, fcaApiService: FcaApiService);
+    list(params?: RequestStorageListParams): Promise<ResponseList<StorageElement>>;
+    info(params: {
+        path: string;
+        divide_id?: number;
+        file_version_id?: string;
+    }): Promise<StorageElement>;
+    combineInfo({ root, rootId, path, file_version_id, }: StorageRouteData): Promise<StorageElement>;
+    size(data: StorageItemSizeParams): Promise<number>;
+    move(params: StorageElementPasteParams, to: StorageRoot, from: StorageRoot): Promise<void>;
+    copy(params: StorageElementPasteParams, from: StorageRoot, to: StorageRoot): Promise<void>;
+    pasteFromShared(from_sharing_token: string, paths: StorageElementPaste[], from_sharing_password?: string): Promise<void>;
+    create(data: CreateStorageElementParams): Promise<ResponseItem<StorageElement>>;
+    delete(path: string, divide_id?: number): Promise<void>;
+    favorite(path: string): Promise<void>;
+    removeFavorite(path: string): Promise<void>;
+    createItem(data: CreateStorageElementParams): Promise<ResponseItem<StorageElement>>;
+    createWorkDir(data: CreateStorageElementParams): Promise<ResponseItem<StorageElement>>;
+    sizeWithSection(params?: {
+        owner_id: number;
+        with_trash: boolean;
+    }): Promise<SizeBySection[] | null>;
+}
+interface RequestStorageListParams extends RequestBaseParams {
+    search?: string;
+    is_favorite?: boolean;
+    is_divided?: boolean;
+    divide_id?: number | null;
+    path?: string;
+    min_size?: number | null;
+    max_size?: number | null;
+    type?: StorageElementType;
+    file_name_ext?: string[];
+    from_sharing_token?: string;
+    from_path?: string;
+    from_sharing_password?: string;
+}
+interface StorageElementPasteParams {
+    paths: StorageElementPaste[];
+    overwrite: boolean;
+    from_divide_id?: number | null;
+    to_divide_id?: number | null;
+}
+type CreateStorageElementParams = Pick<StorageElement, 'created_by_extension' | 'divide_id' | 'name' | 'type' | 'path'> & {
+    is_work_dir?: boolean;
+};
+interface StorageItemSizeParams {
+    paths: StorageItemSizePathParams[];
+    is_divided?: boolean;
+    is_favorite?: boolean;
+}
+interface StorageItemSizePathParams {
+    path: string;
+    divide_id?: number;
+}
+
+declare class StorageFilesApiService {
+    private client;
+    constructor(client: Client);
+    read(path: string, params: any): Promise<ResponseItem<any>>;
+    replace(params: {
+        path: string;
+        divide_id?: number;
+    }, data: any): Promise<ResponseItem<StorageElement>>;
+    upload(onProgress: OnUploadProgress, file: File, path: string, divide_id?: number): {
+        promise: Promise<HttpEvent<ResponseItem<StorageElement>>>;
+        abort: () => void;
+    };
+    uploadNet(data: UploadNetRequestParams): Promise<ResponseItem<StorageElement>>;
+}
+interface UploadNetRequestParams {
+    path: string;
+    url: string;
+    overwrite?: boolean;
+    divide_id?: number;
+    connection_divide_id?: number;
+}
+
+declare class FcaApiService {
+    private client;
+    constructor(client: Client);
+    info(rootID: number, path: string): Promise<StorageElement>;
+    list(rootID: number, params?: RequestStorageListParams): Promise<ResponseList<StorageElement>>;
+    create(rootID: number, data: CreateStorageElementParams): Promise<any>;
+    replace(rootID: number, path: string, data: any): Promise<ResponseItem<StorageElement>>;
+    read(id: number, path: string): Promise<ResponseItem<any>>;
+    upload(onProgress: OnUploadProgress, rootID: number, file: File, path?: string): {
+        promise: Promise<HttpEvent<ResponseItem<StorageElement>>>;
+        abort: () => void;
+    };
+    uploadNet(rootID: number, params: UploadNetRequestParams): Promise<ResponseItem<StorageElement>>;
+    delete(rootID: number, path: string): Promise<void>;
+    check(data: ConnectionCreateParams): Promise<void>;
+}
+
+declare class GatewayApiService {
+    private client;
+    constructor(client: Client);
+    settings(): Promise<Setting[]>;
+    changeSettings(data: SettingValue[]): Promise<void>;
+    queryInit(): Promise<QueryInitResponse>;
+}
+interface QueryInitResponse {
+    license?: License;
+    unread_notifications?: ResponseList<UserNotification> & {
+        total_all: number;
+    };
+    extensions_apps?: ResponseList<Extension>;
+    extensions_defaults: ResponseList<ExtensionDefault>;
+    me?: User;
+    cache_users: User[];
+    lock_screen: LockScreen;
+    restrictions?: Restriction;
+    open_in_desktop_settings: {
+        open_in_desktop_enabled: boolean;
+    };
+    inject_scripts?: string[];
+}
+
+declare class GroupApiService {
+    private client;
+    constructor(client: Client);
+    list(params: RequestUserGroupListParams): Promise<ResponseList<UserGroup>>;
+    listUsers(id: number): Promise<ResponseList<User>>;
+    create(data: CreateUserGroupParams): Promise<ResponseItem<UserGroup>>;
+    update(id: number, data: CreateUserGroupParams): Promise<ResponseItem<UserGroup>>;
+    delete(id: number): Promise<void>;
+}
+interface RequestUserGroupListParams extends RequestBaseParams {
+    id?: number[];
+    name?: string;
+    description?: string;
+    search_field?: string;
+}
+type CreateUserGroupParams = Pick<UserGroup, 'name' | 'description'> & {
+    users?: number[];
+};
+
+declare class LicenseApiService {
+    private client;
+    constructor(client: Client);
+    info(): Promise<License>;
+    create(data: ChangeLicenseParams): Promise<License>;
+    check(): Promise<License>;
+    delete(): Promise<void>;
+    getHash(): Promise<{
+        hash: string;
+    }>;
+}
+
+declare class LinksApiService {
+    private client;
+    constructor(client: Client);
+    createShortLink(params: CutLinkRequest): Promise<CutLinkResponse>;
+    updateShortLink(params: CutLinkRequest): Promise<CutLinkResponse>;
+}
+interface CutLinkRequest {
+    entity_id: number;
+    entity_type: string;
+    full_url: string;
+    reload_short_url?: boolean;
+}
+interface CutLinkResponse extends CutLinkRequest {
+    full_url: string;
+    short_url: string;
+}
+
+declare class LogstashApiService {
+    private client;
+    constructor(client: Client);
+    getUsersLogs(params: RequestUsersLogParams): Promise<ResponseList<UsersLog>>;
+    getSystemLogs(path: string, start: number, end: number): Promise<HttpResponse<string>>;
+}
+interface RequestUsersLogParams extends RequestBaseParams {
+    user_id?: string;
+    search_field?: string;
+    from_date?: string;
+    to_date?: string;
+    with_me?: boolean;
+}
+
+declare class NotificationApiService {
+    private client;
+    constructor(client: Client);
+    list(params?: RequestNotificationListParams): Promise<ResponseListNotification>;
+    toggleStatus(ids: number[], to_status: NotificationRowAction): Promise<void>;
+    toggleAllStatus(to_status: NotificationRowAction): Promise<void>;
+    delete(id: number[]): Promise<void>;
+    deleteAll(): Promise<void>;
+    getPermission(): Promise<{
+        enabled: boolean;
+    }>;
+    setPermission(permission: boolean): Promise<void>;
+    getSubscription(): Promise<NotificationActionGroup>;
+    setSubscription(data: NotificationActionGroup): Promise<void>;
+}
+interface RequestNotificationListParams extends RequestBaseParams {
+    read?: boolean;
+    search?: string;
+    lang?: string;
+}
+type ResponseListNotification = ResponseList<UserNotification> & {
+    total_all: number;
+};
+
+declare class RoleApiService {
+    private client;
+    constructor(client: Client);
+    list(params?: RequestUserRoleListParams): Promise<ResponseList<UserRole>>;
+    get(id: number): Promise<ResponseItem<UserRole>>;
+    getDefault(): Promise<ResponseItem<UserRole>>;
+    create(data: CreateUserRoleParams): Promise<ResponseItem<UserRole>>;
+    update(id: number, data: Partial<CreateUserRoleParams>): Promise<ResponseItem<UserRole>>;
+    delete(id: number): Promise<void>;
+    permissionList(): Promise<ResponseList<Permission>>;
+    addPermission(id: number, ids: number[]): Promise<void>;
+    deletePermission(id: number, ids: number[]): Promise<void>;
+}
+interface RequestUserRoleListParams extends RequestBaseParams {
+    id?: number[];
+    search_field?: string;
+}
+type CreateUserRoleParams = Pick<UserRole, 'name' | 'description' | 'grant_access_all' | 'is_default'>;
+
+declare class ShareApiService {
+    private client;
+    constructor(client: Client);
+    info(path: string, share_token: string): Promise<ShareInfo>;
+    checkPassword(password: string, share_token: string): Promise<any>;
+    checkToken(share_token: string): Promise<any>;
+    getRestriction(token: string): Promise<UnionRestriction>;
+    restrictions(params?: RequestBaseParams): Promise<ResponseList<ShareInfo>>;
+    restrictionsChange(token: string, data: {
+        status: RestrictionStatus;
+        comment: string;
+    }): Promise<ResponseList<ShareInfo>>;
+}
+
+declare class StorageInstanceApiService {
+    private client;
+    constructor(client: Client);
+    instance(): Promise<ResponseList<StorageInstance>>;
+}
+
+declare class StorageShareApiService {
+    private client;
+    constructor(client: Client);
+    info(path: string): Promise<ShareInfo>;
+    create(path: string, permissions_type: PermissionType): Promise<ShareInfo>;
+    change(data: ShareModel): Promise<ShareInfo>;
+    delete(path: string): Promise<void>;
+    refresh(token: string): Promise<ShareInfo>;
+}
+
+declare class StorageTrashApiService {
+    private client;
+    constructor(client: Client);
+    list(params: RequestStorageListParams): Promise<ResponseList<StorageTrashElement>>;
+    clear(item: StorageTrashItem): Promise<void>;
+    clearAll(): Promise<void>;
+    restore(del_groups: StorageTrashItem[]): Promise<void>;
+}
+
+declare class UserApiService {
+    private client;
+    constructor(client: Client);
+    list(params: RequestUserListParams): Promise<ResponseList<User>>;
+    get(id: number): Promise<ResponseItem<User>>;
+    create(data: CreateUserParams): Promise<ResponseItem<User>>;
+    update(id: number, data: CreateUserParams): Promise<ResponseItem<User>>;
+    delete(id: number, params?: {
+        hard: boolean;
+    }): Promise<void>;
+    restore(id: number): Promise<void>;
+    me(): Promise<ResponseItem<User>>;
+    updateMe(data: CreateUserParams): Promise<ResponseItem<User>>;
+    createToken(data: {
+        name: string;
+        expire_in: string | null;
+    }): Promise<UserToken>;
+    listToken(params: RequestBaseParams): Promise<ResponseList<UserToken>>;
+    deleteToken(id: number): Promise<void>;
+    changeMyPassword(data: {
+        new_password: string;
+        old_password: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    changeUsersPassword(id: number, data: {
+        new_password: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    meUploadAvatar(file: Blob, fileName: string): Promise<{
+        file_path: string;
+    }>;
+    meDeleteAvatar(): Promise<void>;
+    meListSession(params: RequestBaseParams): Promise<ResponseList<UserSession>>;
+    meDeleteSession(id?: number): Promise<void>;
+    setRole(id: number, role_id?: number | null): Promise<void>;
+}
+interface RequestUserListParams extends RequestBaseParams {
+    email?: string;
+    first_name?: string;
+    middle_name?: string;
+    last_name?: string;
+    login?: string;
+    is_admin?: boolean;
+    id?: number[];
+    role_ids?: number[];
+    statuses?: UserStatus[];
+    search_field?: string;
+    with_me?: boolean;
+    type?: UserType;
+    exclude_type?: UserType;
+    exclude_ids?: number[];
+}
+type CreateUserParams = Pick<User, 'first_name' | 'last_name' | 'middle_name' | 'email' | 'home_path' | 'password' | 'role_id'>;
+
+declare class VersionApiService {
+    private client;
+    constructor(client: Client);
+    history(params: HistoryRequestParams): Promise<ResponseList<StorageElementHistory>>;
+    versions(params: HistoryListRequestParams): Promise<ResponseList<StorageElementVersion>>;
+    create(params: HistoryNote): Promise<ResponseItem<StorageElementVersion>>;
+    edit(params: HistoryNote): Promise<ResponseItem<StorageElementVersion>>;
+    delete(params: HistoryRequestParams): Promise<void>;
+    size(params: HistoryRequestParams): Promise<number>;
+    makeCurrent(params: HistoryRequestParams): Promise<void>;
+}
+type HistoryListRequestParams = HistoryRequestParams & RequestBaseParams;
+interface HistoryRequestParams {
+    path: string;
+    divide_id?: number | null;
+    file_version_id?: string;
+}
+
+declare const applyInterceptors: <T>(interceptors: {
+    fulfilled: (arg: T) => T | Promise<T>;
+    rejected?: (error: any) => T | Promise<T>;
+}[], arg: T) => Promise<T>;
+
+declare function getCookieValue(name: string): string | null;
+
+declare const makeUrlParams: (params: Record<string, any>) => URLSearchParams;
+
+declare function normalizeHeaders(headers: Headers | [string, string][] | Record<string, string>): Record<string, string>;
+
+export { AccessRights, type AccessToken, AuthApiService, type AuthToken, type AuthType, BASE_URL_V1, BASE_URL_V2, CONNECTIONS_PERMISSION, type ChangeLicenseParams, Client, type Connection, type ConnectionCreateParams, ConnectionGroup, ConnectionType, ConnectionsApiService, type CreateStorageElementParams, type CreateUserGroupParams, type CreateUserParams, type CreateUserRoleParams, type CutLinkRequest, type Discovery, DiscoveryApiService, DivideApiService, DivideMode, type DivideResourceType, type DivideResponseList, DivideScope, EngineType, type Extension, type ExtensionDefault, type ExtensionExternal, type ExtensionExternalInList, type ExtensionExternalListParams, ExtensionFileMode, type ExtensionListParams, type ExtensionMetaPayload, ExtensionType, ExtensionsApiService, ExtensionsExternalApiService, FcaApiService, GatewayApiService, GroupApiService, HOST, type HistoryListRequestParams, type HistoryNote, type HistoryRequestParams, type HttpEvent, type HttpResponse, type Lang, type License, LicenseApiService, LicenseError, LinksApiService, type LockScreen, LogstashApiService, type NbAppState, type NbClientParams, type NbRequestParams, NotificationAction, type NotificationActionGroup, NotificationApiService, NotificationEntityType, type NotificationPayload, NotificationRowAction, NotificationStyle, type OnUploadProgress, OrderDirection, type PayloadFile, type Permission, type PermissionItem, PermissionType, type ProgressEvent, type QueryInitResponse, type RequestAuthSettingsParams, type RequestAuthTokenParams, type RequestBaseParams, type RequestConfig, type RequestConnectionParams, RequestMethod, type RequestNotificationListParams, RequestObserve, type RequestStorageListParams, type RequestUserDivideParams, type RequestUserGroupListParams, type RequestUserListParams, type RequestUserRoleListParams, type RequestUsersLogParams, type RequestVersionsSizeParams, type ResponseItem, type ResponseList, type ResponseListNotification, ResponseType, Rest, type Restriction, RestrictionBooleanStatus, RestrictionModeKey, RestrictionSharing, RestrictionStatus, RoleApiService, type Setting, SettingControlType, type SettingField, type SettingFieldView, type SettingLang, type SettingValue, type SettingValueField, type SettingVariant, type SettingViewConnectionChoose, type SettingViewSelect, ShareApiService, type ShareInfo, type ShareModel, type SizeBySection, type StorageElement, StorageElementApiService, StorageElementCheckStatus, StorageElementContentType, type StorageElementHistory, StorageElementHistoryAction, type StorageElementPaste, type StorageElementPasteParams, StorageElementType, type StorageElementVersion, StorageFilesApiService, type StorageInstance, StorageInstanceApiService, type StorageItemSizeParams, type StorageItemSizePathParams, StorageRoot, type StorageRouteData, StorageShareApiService, StorageTrashApiService, type StorageTrashElement, type StorageTrashItem, Tariff, TokenUpdate, type UnionRestriction, type UploadNetRequestParams, type User, UserApiService, UserAuthType, type UserDivide, type UserGroup, type UserLabel, type UserNotification, type UserRole, type UserSession, UserStatus, type UserToken, UserType, type UsersLog, VersionApiService, applyInterceptors, getCookieValue, makeUrlParams, normalizeHeaders };