@fett/synology-api 0.0.2-beta.2 → 0.0.2

package/lib/modules/Core/System.d.ts

@@ -0,0 +1,159 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type SystemStatusResponse = SynologyApiResponse<{
+    is_system_crashed: boolean;
+    upgrade_ready: boolean;
+}>;
+export declare function getSystemStatus(): Promise<SystemStatusResponse>;
+export type SystemInfoResponse = SynologyApiResponse<{
+    cpu_clock_speed: number;
+    cpu_cores: string;
+    cpu_family: string;
+    cpu_series: string;
+    cpu_vendor: string;
+    enabled_ntp: boolean;
+    external_pci_slot_info: Array<any>;
+    firmware_date: string;
+    firmware_ver: string;
+    model: string;
+    ntp_server: string;
+    ram_size: number;
+    sata_dev: Array<any>;
+    serial: string;
+    support_esata: string;
+    sys_temp: number;
+    sys_tempwarn: boolean;
+    systempwarn: boolean;
+    temperature_warning: boolean;
+    time: string;
+    time_zone: string;
+    time_zone_desc: string;
+    up_time: string;
+    usb_dev: Array<any>;
+}>;
+export declare function getSystemInfo(): Promise<SystemInfoResponse>;
+export type SystemStorageInfoResponse = SynologyApiResponse<{
+    hdd_info: Array<{
+        capacity: string;
+        diskPath: string;
+        diskType: string;
+        diskno: string;
+        ebox_order: number;
+        model: string;
+        order: number;
+        overview_status: string;
+        pciSlot: number;
+        portType: string;
+        status: string;
+        summary_status_category: string;
+        summary_status_key: string;
+        temp: number;
+        testing_progress: string;
+        testing_type: string;
+        volume: string;
+    }>;
+    vol_info: Array<{
+        desc: string;
+        inode_free: string;
+        inode_total: string;
+        name: string;
+        status: string;
+        total_size: string;
+        used_size: string;
+        vol_desc: string;
+        volume: string;
+    }>;
+}>;
+export declare function getSystemStorageInfo(): Promise<SystemStorageInfoResponse>;
+export type SystemHealthResponse = SynologyApiResponse<{
+    hostname: string;
+    interfaces: Array<{
+        id: string;
+        ip: string;
+        type: string;
+    }>;
+    rule: {
+        description: {
+            description_format: string;
+            description_params: Array<string>;
+            description_use_formatted: boolean;
+        };
+        id: string;
+        priority: number;
+        type: number;
+    };
+    uptime: string;
+}>;
+export declare function getSystemHealth(): Promise<SystemHealthResponse>;
+export type CoreSystemUtilizationResponse = SynologyApiResponse<{
+    cpu: {
+        "15min_load": number;
+        "1min_load": number;
+        "5min_load": number;
+        device: string;
+        other_load: number;
+        system_load: number;
+        user_load: number;
+    };
+    disk: {
+        disk: Array<{
+            device: string;
+            display_name: string;
+            read_access: number;
+            read_byte: number;
+            type: string;
+            utilization: number;
+            write_access: number;
+            write_byte: number;
+        }>;
+        total: {
+            device: string;
+            read_access: number;
+            read_byte: number;
+            utilization: number;
+            write_access: number;
+            write_byte: number;
+        };
+    };
+    lun: Array<any>;
+    memory: {
+        avail_real: number;
+        avail_swap: number;
+        buffer: number;
+        cached: number;
+        device: string;
+        memory_size: number;
+        real_usage: number;
+        si_disk: number;
+        so_disk: number;
+        swap_usage: number;
+        total_real: number;
+        total_swap: number;
+    };
+    network: Array<{
+        device: string;
+        rx: number;
+        tx: number;
+    }>;
+    nfs: Array<any>;
+    space: {
+        total: {
+            device: string;
+            read_access: number;
+            read_byte: number;
+            utilization: number;
+            write_access: number;
+            write_byte: number;
+        };
+        volume: Array<{
+            device: string;
+            display_name: string;
+            read_access: number;
+            read_byte: number;
+            utilization: number;
+            write_access: number;
+            write_byte: number;
+        }>;
+    };
+    time: number;
+}>;
+export declare function getSystemUtilization(): Promise<CoreSystemUtilizationResponse>;

package/lib/modules/Core/System.js

@@ -0,0 +1,42 @@
+import { CoreApi } from "../../types/index.js";
+export async function getSystemStatus() {
+    const res = await this.run(CoreApi.SystemStatus, {
+        params: {
+            method: "get",
+        },
+    });
+    return res;
+}
+export async function getSystemInfo() {
+    const res = await this.run(CoreApi.System, {
+        params: {
+            method: "info",
+        },
+    });
+    return res;
+}
+export async function getSystemStorageInfo() {
+    const res = await this.run(CoreApi.System, {
+        params: {
+            method: "info",
+            type: "storage",
+        },
+    });
+    return res;
+}
+export async function getSystemHealth() {
+    const res = await this.run(CoreApi.SystemHealth, {
+        params: {
+            method: "get",
+        },
+    });
+    return res;
+}
+export async function getSystemUtilization() {
+    const res = await this.run(CoreApi.SystemUtilization, {
+        params: {
+            method: "get",
+        },
+    });
+    return res;
+}

package/lib/modules/Core/User.d.ts

@@ -0,0 +1,51 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type UserListParams = {
+    offset?: number;
+    limit?: number;
+    sort_by?: string;
+    sort_direction?: "ASC" | "DESC";
+    additional?: Array<"description" | "email" | "expired" | "cannot_chg_passwd" | "passwd_never_expire" | "password_last_change" | "groups" | "2fa_status">;
+};
+export type UserListResponse = SynologyApiResponse<{
+    offset: number;
+    total: number;
+    users: Array<{
+        description: string;
+        email: string;
+        expired: string;
+        name: string;
+        passwd_never_expire: boolean;
+    }>;
+}>;
+export declare function getUserList(params?: UserListParams): Promise<UserListResponse>;
+export type UserInfoParams = {
+    name: string;
+    additional?: Array<"description" | "email" | "expired" | "cannot_chg_passwd" | "passwd_never_expire" | "password_last_change">;
+};
+export type UserInfoResponse = SynologyApiResponse<{
+    offset: number;
+    total: number;
+    users: Array<{
+        description: string;
+        email: string;
+        expired: string;
+        name: string;
+        passwd_never_expire: boolean;
+    }>;
+}>;
+export declare function getUserInfo(params: UserInfoParams): Promise<UserInfoResponse>;
+export type CreateUserParams = {
+    name: string;
+    description: string;
+    email: string;
+    expired?: string;
+    cannot_chg_passwd?: boolean;
+    passwd_never_expire?: boolean;
+    notify_by_email?: boolean;
+    send_password?: boolean;
+};
+export type CreateUserResponse = SynologyApiResponse<{
+    uid: number;
+    name: string;
+}>;
+export declare function createUser(params: CreateUserParams): Promise<CreateUserResponse>;

package/lib/modules/Core/User.js

@@ -0,0 +1,33 @@
+import { CoreApi } from "../../types/index.js";
+export async function getUserList(params) {
+    const { additional = ["email", "description", "expired"] } = params || {};
+    const res = await this.run(CoreApi.User, {
+        params: {
+            ...params,
+            method: "list",
+            additional: JSON.stringify(additional),
+        },
+    });
+    return res;
+}
+export async function getUserInfo(params) {
+    const { additional = [] } = params;
+    const res = await this.run(CoreApi.User, {
+        params: {
+            ...params,
+            method: "get",
+            type: "local",
+            additional: JSON.stringify(additional),
+        },
+    });
+    return res;
+}
+export async function createUser(params) {
+    const res = await this.run(CoreApi.User, {
+        params: {
+            method: "create",
+            ...params,
+        },
+    });
+    return res;
+}

package/lib/modules/Core/index.d.ts

@@ -0,0 +1,14 @@
+import { getSystemStatus, getSystemInfo, getSystemStorageInfo, getSystemHealth, getSystemUtilization } from "./System.js";
+import { getUserList, getUserInfo } from "./User.js";
+export declare const METHODS: {
+    getSystemStorageInfo: typeof getSystemStorageInfo;
+    getSystemHealth: typeof getSystemHealth;
+    getSystemUtilization: typeof getSystemUtilization;
+    getSystemInfo: typeof getSystemInfo;
+    getSystemStatus: typeof getSystemStatus;
+    getUserList: typeof getUserList;
+    getUserInfo: typeof getUserInfo;
+};
+export declare const KEY = "Core";
+export declare const ALIAS_KEY = "co";
+export type TMethods = typeof METHODS;

package/lib/modules/Core/index.js

@@ -0,0 +1,15 @@
+import { getSystemStatus, getSystemInfo, getSystemStorageInfo, getSystemHealth, getSystemUtilization, } from "./System.js";
+import { getUserList, getUserInfo } from "./User.js";
+// methods
+export const METHODS = {
+    getSystemStorageInfo,
+    getSystemHealth,
+    getSystemUtilization,
+    getSystemInfo,
+    getSystemStatus,
+    getUserList,
+    getUserInfo,
+};
+// name space
+export const KEY = "Core";
+export const ALIAS_KEY = "co";

package/lib/modules/Docker/Container.d.ts

@@ -0,0 +1,43 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type DockerContainerListParams = {
+    type: string;
+    limit: number;
+    offset: number;
+};
+export type DockerContainerListResponse = SynologyApiResponse<{
+    containers: Array<{
+        State: {
+            Dead: boolean;
+            Error: string;
+            ExitCode: number;
+            FinishedAt: string;
+            FinishedTs: number;
+            OOMKilled: boolean;
+            Paused: boolean;
+            Pid: number;
+            Restarting: boolean;
+            Running: boolean;
+            StartedAt: string;
+            StartedTs: number;
+            Status: string;
+        };
+        cmd: string;
+        created: number;
+        enable_service_portal: boolean;
+        exporting: boolean;
+        finish_time: number;
+        id: string;
+        image: string;
+        is_ddsm: boolean;
+        is_package: boolean;
+        name: string;
+        services: any;
+        status: string;
+        up_status: string;
+        up_time: number;
+    }>;
+    limit: number;
+    offset: number;
+    total: number;
+}>;
+export declare function getContainerList(params?: DockerContainerListParams): Promise<DockerContainerListResponse>;

package/lib/modules/Docker/Container.js

@@ -0,0 +1,13 @@
+import { DockerApi } from "../../types/index.js";
+export async function getContainerList(params) {
+    const { type = "all", limit = -1, offset = 0 } = params || {};
+    const res = await this.run(DockerApi.Container, {
+        params: {
+            method: "list",
+            type,
+            limit,
+            offset,
+        },
+    });
+    return res;
+}

package/lib/modules/Docker/index.d.ts

@@ -0,0 +1,7 @@
+import { getContainerList } from "./Container.js";
+export declare const METHODS: {
+    getContainerList: typeof getContainerList;
+};
+export declare const KEY = "Docker";
+export declare const ALIAS_KEY = "dk";
+export type TMethods = typeof METHODS;

package/lib/modules/Docker/index.js

@@ -0,0 +1,8 @@
+import { getContainerList } from "./Container.js";
+//  methods
+export const METHODS = {
+    getContainerList,
+};
+// name space
+export const KEY = "Docker";
+export const ALIAS_KEY = "dk";

package/lib/modules/FileStation/BackgroundTask.d.ts

@@ -0,0 +1,50 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type BackgroundTaskListParams = {
+    limit?: number;
+    offset?: number;
+    sort_by?: string;
+    sort_direction?: "ASC" | "DESC";
+    api_filter?: string[];
+};
+export type BackgroundTask = {
+    api: string;
+    crtime: number;
+    finished: boolean;
+    method: string;
+    params: {
+        accurate_progress: boolean;
+        dest_folder_path: string;
+        overwrite: boolean;
+        path: Array<string>;
+        remove_src: boolean;
+    };
+    path: string;
+    processed_size: number;
+    processing_path: string;
+    progress: number;
+    taskid: string;
+    total: number;
+    version: number;
+};
+export type BackgroundTaskListResponse = SynologyApiResponse<{
+    offset: number;
+    total: number;
+    tasks: Array<BackgroundTask>;
+}>;
+/**
+ * get background task list
+ */
+export declare function getBackgroundTaskList(params?: BackgroundTaskListParams): Promise<BackgroundTaskListResponse>;
+/**
+ * Delete all finished background tasks.
+ */
+export type ClearFinishedBackgroundTaskParams = {
+    /**
+     * Unique IDs of finished copy, move, delete,
+     * compress or extract tasks. Specify multiple task
+     * IDs by "," and around brackets. If it's not given, all
+     * finished tasks are deleted.
+     */
+    taskid?: string;
+};
+export declare function clearFinishedBackgroundTasks(params?: ClearFinishedBackgroundTaskParams): Promise<SynologyApiResponse<any>>;

package/lib/modules/FileStation/BackgroundTask.js

@@ -0,0 +1,22 @@
+import { FileStationApi } from "../../types/index.js";
+/**
+ * get background task list
+ */
+export async function getBackgroundTaskList(params) {
+    const res = await this.run(FileStationApi.BackgroundTask, {
+        params: {
+            method: "list",
+            ...(params ?? {}),
+        },
+    });
+    return res;
+}
+export async function clearFinishedBackgroundTasks(params) {
+    const res = await this.run(FileStationApi.BackgroundTask, {
+        params: {
+            method: "clear_finished",
+            ...params,
+        },
+    });
+    return res;
+}

package/lib/modules/FileStation/CheckPermission.d.ts

@@ -0,0 +1,10 @@
+import { SynologyApiResponse } from "../../types/index.js";
+/**
+ * Check if a logged-in user has write permission to create new files/folders in a given folder.
+ */
+export declare function checkPermission(params: {
+    path: string;
+    filename: string;
+    overwrite: boolean;
+    create_only: boolean;
+}): Promise<SynologyApiResponse<any>>;

package/lib/modules/FileStation/CheckPermission.js

@@ -0,0 +1,13 @@
+import { FileStationApi } from "../../types/index.js";
+/**
+ * Check if a logged-in user has write permission to create new files/folders in a given folder.
+ */
+export async function checkPermission(params) {
+    const res = await this.run(FileStationApi.CheckPermission, {
+        params: {
+            method: "write",
+            ...params,
+        },
+    });
+    return res;
+}

package/lib/modules/FileStation/CopyMove.d.ts

@@ -0,0 +1,33 @@
+import { SynologyApiResponse } from "../../types/index.js";
+/**
+ * Copy/move file(s)/folder(s).
+ *   This is a non-blocking API. You need to start to copy/move files with start method. Then, you should poll
+ *   requests with status method to get the progress status, or make a request with stop method to cancel the
+ *  operation
+ *
+ */
+export type CopyMoveParams = {
+    path: string;
+    dest_folder_path: string;
+    overwrite?: boolean;
+    remove_src?: boolean;
+    search_taskid?: string;
+    accurate_progress?: boolean;
+};
+export declare function startCopyMove(params: CopyMoveParams): Promise<SynologyApiResponse<{
+    taskid: string;
+}>>;
+export type CopyMoveStatusResponse = SynologyApiResponse<{
+    finished: boolean;
+    path: string;
+    processed_size: number;
+    progress: number;
+    total: number;
+    dest_folder_path: string;
+}>;
+export declare function getCopyMoveStatus(params: {
+    taskid: string;
+}): Promise<CopyMoveStatusResponse>;
+export declare function stopCopyMove(params: {
+    taskid: string;
+}): Promise<SynologyApiResponse<any>>;

package/lib/modules/FileStation/CopyMove.js

@@ -0,0 +1,28 @@
+import { FileStationApi } from "../../types/index.js";
+export async function startCopyMove(params) {
+    const res = await this.run(FileStationApi.CopyMove, {
+        params: {
+            method: "start",
+            ...params,
+        },
+    });
+    return res;
+}
+export async function getCopyMoveStatus(params) {
+    const res = await this.run(FileStationApi.CopyMove, {
+        params: {
+            method: "status",
+            taskid: params.taskid,
+        }
+    });
+    return res;
+}
+export async function stopCopyMove(params) {
+    const res = await this.run(FileStationApi.CopyMove, {
+        params: {
+            method: "stop",
+            taskid: params.taskid,
+        }
+    });
+    return res;
+}

package/lib/modules/FileStation/CreateFolder.d.ts

@@ -0,0 +1,15 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type CreateFolderParams = {
+    folder_path: string;
+    name: string;
+    force_parent?: boolean;
+    additional: Array<"real_path" | "size" | "owner" | "time" | "perm" | "type">;
+};
+export type CreateFolderResponse = SynologyApiResponse<{
+    folders: Array<{
+        isdir: boolean;
+        name: string;
+        path: string;
+    }>;
+}>;
+export declare function createFolder(params: CreateFolderParams): Promise<CreateFolderResponse>;

package/lib/modules/FileStation/CreateFolder.js

@@ -0,0 +1,12 @@
+import { FileStationApi } from "../../types/index.js";
+export async function createFolder(params) {
+    const { additional = [] } = params;
+    const res = await this.run(FileStationApi.CreateFolder, {
+        params: {
+            method: "create",
+            ...params,
+            additional: JSON.stringify(additional),
+        },
+    });
+    return res;
+}

package/lib/modules/FileStation/Delete.d.ts

@@ -0,0 +1,54 @@
+import { SynologyApiResponse } from "../../types/index.js";
+export type DeleteFileParams = {
+    /**
+     * One or more copied/moved
+  file/folder path(s) starting with a
+  shared folder, separated by
+  commas "," and around brackets.
+    */
+    path: string | string[];
+    /**
+   *  true : calculate the
+  progress by each moved/copied file
+  within sub-folder. false : calculate
+  the progress by files which you give
+  in path parameters. This calculates
+  the progr
+  */
+    accurate_progress?: boolean;
+    /**
+   *  true : delete
+  recursively. false : delete
+  non-empty folder.
+   */
+    recursive?: boolean;
+    /**
+     * A unique ID for the search
+  task which is obtained from start
+  method. It's used to delete the file in
+  the search result
+    */
+    search_taskid?: string;
+};
+export type DeleteFileResponse = SynologyApiResponse<{
+    taskid: string;
+}>;
+export declare function startDeleteFile(params: DeleteFileParams): Promise<DeleteFileResponse>;
+export declare function stopDeleteFile(params: {
+    taskid: string;
+}): Promise<SynologyApiResponse<any>>;
+export type DeleteFileStatusResponse = SynologyApiResponse<{
+    finished: boolean;
+    found_dir_num: number;
+    found_file_num: number;
+    found_file_size: number;
+    has_dir: boolean;
+    path: string;
+    processed_num: number;
+    processing_path: string;
+    progress: number;
+    total: number;
+}>;
+export declare function getDeleteFileStatus(params: {
+    taskid: string;
+}): Promise<DeleteFileResponse>;