nb-js-client 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,1051 @@
+interface AuthToken {
+    access_token: string;
+    refresh_token: string;
+}
+interface AuthType {
+    classic: boolean;
+    basic: boolean;
+    ldap: boolean;
+}
+
+interface NbClientParams {
+    host: string;
+    version?: number;
+}
+interface NbRequestParams {
+    path: string;
+    headers?: Record<string, any>;
+    query?: Record<string, any>;
+    body?: any;
+    cache?: RequestCache;
+}
+interface NbAppState {
+    clientParams: NbClientParams;
+    requestParams: NbRequestParams;
+}
+interface ResponseItem<T> {
+    row: T;
+}
+interface ResponseList<T> {
+    rows: T[];
+    total: number;
+}
+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 = ""
+}
+declare enum StorageRoot {
+    my = "my",
+    fca = "fca",
+    divide = "divide",
+    share = "share",
+    favorite = "favorite"
+}
+
+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'>;
+declare enum UserAuthType {
+    Native = "native",
+    Ldap = "ldap"
+}
+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 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;
+}
+type CreateUserParams = Pick<User, 'first_name' | 'last_name' | 'middle_name' | 'email' | 'home_path' | 'password' | 'role_id'>;
+
+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 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: User;
+    owner_id: number;
+    version?: StorageElementVersion;
+    divide_id?: number;
+    access_mode?: PermissionType;
+    to_user_group_name?: string;
+    created_by_extension?: string;
+}
+type CreateStorageElementParams = Pick<StorageElement, 'created_by_extension' | 'divide_id' | 'name' | 'type' | 'path'> & {
+    is_work_dir?: boolean;
+};
+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"
+}
+interface StorageElementPaste {
+    from_path: string;
+    to_path: string;
+}
+interface StorageElementPasteParams {
+    paths: StorageElementPaste[];
+    overwrite: boolean;
+    from_divide_id?: number | null;
+    to_divide_id?: number | null;
+}
+interface StorageElementVersion {
+    id: string;
+    size: number;
+    user_id: number;
+    name: string;
+    description: string;
+    create_date: string;
+    update_date: string;
+    is_current_version: boolean;
+}
+interface StorageElementHistory {
+    user_id: number;
+    action: StorageElementHistoryAction;
+    create_date: string;
+}
+declare enum StorageElementHistoryAction {
+    Create = "create",
+    Update = "update",
+    Move = "move"
+}
+interface StorageElementHistoryNote {
+    name: string;
+    description: string;
+    divide_id: number | null;
+    file_version_id: string;
+    path: string;
+}
+interface RequestHistoryListParams extends RequestBaseParams {
+    path: string;
+    divide_id?: number | null;
+}
+interface UploadNetRequestParams {
+    path: string;
+    url: string;
+    overwrite?: boolean;
+    divide_id?: number;
+}
+
+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 {
+    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;
+}
+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;
+}
+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 Connection {
+    id: number;
+    name: string;
+    type: ConnectionType;
+    address: string;
+    login: string;
+    password: string;
+    port: number;
+    root_path: string;
+    group_name: ConnectionGroup;
+    divide_id?: number;
+    access_mode?: PermissionType;
+    owner?: Pick<User, 'first_name' | 'last_name' | 'login' | 'middle_name'>;
+    update_date: string;
+    create_date: string;
+    expire_in: string;
+    to_user_group_name?: string;
+}
+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 RequestConnectionParams extends RequestBaseParams {
+    name?: string | null;
+    group_name?: ConnectionGroup;
+    is_divided?: boolean;
+    type?: string;
+}
+type ConnectionCreateParams = Omit<Connection, 'group_name'>;
+
+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;
+    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 ExtensionListParams extends RequestBaseParams {
+    search?: string | null;
+    uniq_key?: string[];
+    file_name_ext?: string;
+    type?: StorageElementType[];
+    ext_value?: string | null;
+    file_mode?: ExtensionFileMode[];
+    lang?: string;
+}
+interface ExtensionExternalListParams extends RequestBaseParams {
+    search_field?: 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 Group {
+    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 RequestGroupListParams extends RequestBaseParams {
+    id?: number[];
+    name?: string;
+    description?: string;
+    search_field?: string;
+}
+type CreateGroupParams = Pick<Group, 'name' | 'description'> & {
+    users?: 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;
+}
+type RequestNotificationListParams = RequestBaseParams & {
+    read?: boolean;
+    search?: string;
+};
+type ResponseListNotification = ResponseList<UserNotification> & {
+    total_all: number;
+};
+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",
+    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 RestrictionSharing {
+    NONE = "none",
+    SOFT = "soft",
+    HARD = "hard"
+}
+interface Restriction {
+    sharing: RestrictionSharing;
+    divide: RestrictionSharing;
+}
+
+interface QueryInit {
+    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[];
+}
+
+interface Role {
+    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 RequestRoleListParams extends RequestBaseParams {
+    id?: number[];
+    search_field?: string;
+}
+type CreateRoleParams = Pick<Role, 'name' | 'description' | 'grant_access_all' | 'is_default'>;
+
+interface UsersLog {
+    create_date: string;
+    service_name: string;
+    user_login: string;
+    event_type: string;
+    action: string;
+    resource: string;
+    description: string;
+}
+interface RequestUsersLogParams extends RequestBaseParams {
+    user_id?: string;
+    search_field?: string;
+    from_date?: string;
+    to_date?: string;
+    with_me?: boolean;
+}
+
+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;
+    with_preview: boolean;
+}
+type StorageTrashItem = Pick<StorageTrashElement, 'del_group_id' | 'path'>;
+
+declare class NotificationsApiService {
+    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>;
+}
+
+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(file: File, path: string, divide_id?: number): Promise<ResponseItem<StorageElement>>;
+    uploadNet(data: UploadNetRequestParams): Promise<ResponseItem<StorageElement>>;
+}
+
+type Interceptor<T = any> = {
+    fulfilled: (value: T) => T | Promise<T>;
+    rejected: (error: any) => any;
+};
+
+declare class Client {
+    state: NbAppState;
+    rest: Rest;
+    AuthApi: AuthApiService;
+    ConnectionsApi: ConnectionsApiService;
+    DiscoveryApi: DiscoveryApiService;
+    DivideApi: DivideApiService;
+    ExtensionsApi: ExtensionsApiService;
+    ExtensionsExternalApi: ExtensionsExternalApiService;
+    FcaApi: FcaApiService;
+    GatewayApi: GatewayApiService;
+    GroupApi: GroupApiService;
+    LicenseApi: LicenseApiService;
+    LogstashApi: LogstashApiService;
+    NotificationsApi: NotificationsApiService;
+    RoleApi: RoleApiService;
+    ShareApi: ShareApiService;
+    StorageElementApi: StorageElementApiService;
+    StorageFilesApi: StorageFilesApiService;
+    StorageShareApi: StorageShareApiService;
+    StorageTrashApi: StorageTrashApiService;
+    UserApi: UserApiService;
+    requestInterceptors: Interceptor<RequestInit>[];
+    responseInterceptors: Interceptor<Response>[];
+    constructor(clientParams: NbClientParams);
+    request: {
+        use: (fulfilled: (config: RequestInit) => RequestInit | Promise<RequestInit>, rejected: (error: any) => any) => void;
+    };
+    response: {
+        use: (fulfilled: (response: Response) => Response | Promise<Response>, rejected: (error: any) => any) => void;
+    };
+    resetParams(params: Partial<NbClientParams & NbRequestParams>): void;
+}
+
+declare class Rest {
+    private client;
+    constructor(client: Client);
+    get state(): NbAppState;
+    get(path: string, query?: Record<string, any>): Promise<any>;
+    post(path: string, body?: BodyInit | null): Promise<any>;
+    put(path: string, body?: BodyInit | null): Promise<any>;
+    patch(path: string, body?: BodyInit | null): Promise<any>;
+    delete(path: string, query?: Record<string, any>): Promise<any>;
+    private request;
+}
+
+declare class AuthApiService {
+    private client;
+    constructor(client: Client);
+    info(): Promise<AuthType>;
+    login(data: {
+        login: string;
+        password: string;
+        is_remember: boolean;
+    }): Promise<AuthToken>;
+    ldapLogin(data: {
+        login: string;
+        password: string;
+        is_remember: boolean;
+    }): Promise<AuthToken>;
+    updateToken(data: AuthToken): Promise<any>;
+    logout(): Promise<void>;
+}
+
+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>>;
+}
+
+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>;
+    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(file: File): Promise<ResponseItem<Extension>>;
+    install(uniq_key: string, version: string): Promise<any>;
+}
+
+declare class ExtensionsExternalApiService {
+    private client;
+    constructor(client: Client);
+    listExtensionsSite(params: ExtensionExternalListParams): Promise<ResponseList<ExtensionExternalInList>>;
+    extensionDetailSite(uniqKey: string): Promise<ExtensionExternal>;
+    extensionMarkdown(uniqKey: string): Promise<string>;
+}
+
+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(rootID: number, file: File, path?: string): 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<QueryInit>;
+}
+
+declare class GroupApiService {
+    private client;
+    constructor(client: Client);
+    list(params: RequestGroupListParams): Promise<ResponseList<Group>>;
+    listUsers(id: number): Promise<ResponseList<User>>;
+    create(data: CreateGroupParams): Promise<ResponseItem<Group>>;
+    update(id: number, data: CreateGroupParams): Promise<ResponseItem<Group>>;
+    delete(id: number): Promise<void>;
+}
+
+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 LogstashApiService {
+    private client;
+    constructor(client: Client);
+    getUsersLogs(params: RequestUsersLogParams): Promise<ResponseList<UsersLog>>;
+    getSystemLogs(path: string): Promise<string>;
+}
+
+declare class RoleApiService {
+    private client;
+    constructor(client: Client);
+    list(params?: RequestRoleListParams): Promise<ResponseList<Role>>;
+    get(id: number): Promise<ResponseItem<Role>>;
+    getDefault(): Promise<ResponseItem<Role>>;
+    create(data: CreateRoleParams): Promise<ResponseItem<Role>>;
+    update(id: number, data: CreateRoleParams): Promise<ResponseItem<Role>>;
+    delete(id: number): Promise<void>;
+    permissions(): Promise<ResponseList<Permission>>;
+    addPermissions(id: number, ids: number[]): Promise<void>;
+    deletePermissions(id: number, ids: number[]): 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>;
+}
+
+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>;
+    restrictions(params?: RequestBaseParams): Promise<ResponseList<ShareInfo>>;
+    restrictionsChange(token: string, data: {
+        status: RestrictionStatus;
+        comment: string;
+    }): Promise<ResponseList<ShareInfo>>;
+}
+
+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 StorageElementApiService {
+    private client;
+    constructor(client: Client);
+    list(params?: RequestStorageListParams): Promise<ResponseList<StorageElement>>;
+    info(params: {
+        path: string;
+        divide_id?: number;
+        file_version_id?: string;
+    }): Promise<StorageElement>;
+    size(data: {
+        paths: string[];
+        divide_id?: number;
+    }): Promise<number>;
+    move(data: StorageElementPasteParams, hasFCA?: boolean): 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>>;
+    history(params: RequestHistoryListParams): Promise<ResponseList<StorageElementHistory>>;
+    versions(params: RequestHistoryListParams): Promise<ResponseList<StorageElementVersion>>;
+    createVersion(data: StorageElementHistoryNote): Promise<ResponseItem<StorageElementVersion>>;
+    editVersion(data: StorageElementHistoryNote): Promise<ResponseItem<StorageElementVersion>>;
+    deleteVersion(params: RequestHistoryListParams): Promise<void>;
+    makeCurrentVersion(data: RequestHistoryListParams): Promise<void>;
+}
+
+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 function sendRequest(method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE', params: NbClientParams, options: NbRequestParams, interceptors: {
+    request: Interceptor<RequestInit>[];
+    response: Interceptor<Response>[];
+}): Promise<Response>;
+
+export { AuthApiService, type AuthToken, type AuthType, type ChangeLicenseParams, Client, type Connection, type ConnectionCreateParams, ConnectionGroup, ConnectionType, ConnectionsApiService, type CreateGroupParams, type CreateRoleParams, type CreateStorageElementParams, type CreateUserParams, 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, type Group, GroupApiService, type Lang, type License, LicenseApiService, LicenseError, type LockScreen, LogstashApiService, type NbAppState, type NbClientParams, type NbRequestParams, NotificationAction, type NotificationActionGroup, NotificationEntityType, type NotificationPayload, NotificationRowAction, NotificationStyle, OrderDirection, type PayloadFile, type Permission, type PermissionItem, PermissionType, type QueryInit, type RequestBaseParams, type RequestConnectionParams, type RequestGroupListParams, type RequestHistoryListParams, type RequestNotificationListParams, type RequestRoleListParams, type RequestStorageListParams, type RequestUserDivideParams, type RequestUserListParams, type RequestUsersLogParams, type ResponseItem, type ResponseList, type ResponseListNotification, Rest, type Restriction, RestrictionBooleanStatus, RestrictionSharing, RestrictionStatus, type Role, 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 StorageElement, StorageElementApiService, StorageElementContentType, type StorageElementHistory, StorageElementHistoryAction, type StorageElementHistoryNote, type StorageElementPaste, type StorageElementPasteParams, StorageElementType, type StorageElementVersion, StorageRoot, StorageShareApiService, StorageTrashApiService, type StorageTrashElement, type StorageTrashItem, Tariff, type UploadNetRequestParams, type User, UserApiService, UserAuthType, type UserDivide, type UserLabel, type UserNotification, type UserSession, UserStatus, type UserToken, UserType, type UsersLog, sendRequest };