@pelican.ts/sdk 0.2.2 → 0.2.3

package/dist/index.d.mts

@@ -0,0 +1,661 @@
+import { AxiosInstance } from 'axios';
+import WebSocket from 'isomorphic-ws';
+
+type ExactlyOneKey<K extends keyof any, V, KK extends keyof any = K> = {
+    [P in K]: {
+        [Q in P]: V;
+    } & {
+        [Q in Exclude<KK, P>]?: never;
+    } extends infer O ? {
+        [Q in keyof O]: O[Q];
+    } : never;
+}[K];
+type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type Nullable<T> = T | null;
+
+type User$1 = {
+    uuid: string;
+    username: string;
+    email: string;
+    language: string;
+    image: string;
+    admin: boolean;
+    root_admin: boolean;
+    "2fa_enabled": number;
+    created_at: string;
+    updated_at: string;
+};
+type APIKey = {
+    identifier: string;
+    description: string;
+    allowed_ips: string[];
+    last_used_at: Nullable<string>;
+    created_at: string;
+};
+type SSHKey = {
+    name: string;
+    fingerprint: string;
+    pubic_key: string;
+    created_at: string;
+};
+type Permission = {
+    description: string;
+    keys: Record<string, string>;
+};
+
+declare class Account {
+    private readonly r;
+    constructor(requester: AxiosInstance);
+    info: () => Promise<User$1>;
+    updateEmail: (newEmail: string, password: string) => Promise<void>;
+    updatePassword: (newPassword: string) => Promise<void>;
+    apiKeys: {
+        list: () => Promise<APIKey[]>;
+        create: (description: string, allowed_ips?: string[]) => Promise<APIKey & {
+            secret_token: string;
+        }>;
+        delete: (identifier: string) => Promise<void>;
+    };
+    sshKeys: {
+        list: () => Promise<SSHKey[]>;
+        create: (name: string, public_key: string) => Promise<SSHKey>;
+        delete: (fingerprint: string) => Promise<void>;
+    };
+    twoFactor: {
+        info: () => Promise<{
+            image_url_data: string;
+        }>;
+        enable: (code: string) => Promise<{
+            tokens: string[];
+        }>;
+        disable: (password: string) => Promise<void>;
+    };
+}
+
+type GenericResponse<T, N extends string = string, M = undefined> = {
+    object: N;
+    attributes: T;
+    meta?: M;
+};
+type PaginationMeta = {
+    total: number;
+    count: number;
+    per_page: number;
+    current_page: number;
+    total_pages: number;
+    links: any;
+};
+type GenericListResponse<T> = {
+    object: "list";
+    data: T[];
+    meta?: {
+        pagination: PaginationMeta;
+    };
+};
+type CustomListResponse<T, M> = {
+    object: "list";
+    data: T[];
+    meta?: M;
+};
+
+type EggVariable = {
+    name: string;
+    description: string;
+    env_variable: string;
+    default_value: string;
+    server_value: string;
+    is_editable: boolean;
+    rules: string;
+};
+
+type ServerSubuser = {
+    uuid: string;
+    username: string;
+    email: string;
+    language: string;
+    image: string;
+    admin: false;
+    root_admin: false;
+    "2fa_enabled": boolean;
+    created_at: string;
+    permissions: SubuserPermission[] | string[];
+};
+type SubuserPermission = "activity.read" | "allocation.create" | "allocation.delete" | "allocation.read" | "allocation.update" | "backup.create" | "backup.delete" | "backup.download" | "backup.read" | "backup.restore" | "control.console" | "control.restart" | "control.start" | "control.stop" | "database.create" | "database.delete" | "database.read" | "database.update" | "database.view-password" | "file.archive" | "file.create" | "file.delete" | "file.read" | "file.read-content" | "file.sftp" | "file.update" | "schedule.create" | "schedule.delete" | "schedule.read" | "schedule.update" | "settings.description" | "settings.reinstall" | "settings.rename" | "startup.docker-image" | "startup.read" | "startup.update" | "user.create" | "user.delete" | "user.read" | "user.update" | "websocket.connect";
+
+type ServerLimits = {
+    memory: number;
+    swap: number;
+    disk: number;
+    io: number;
+    cpu: number;
+    threads: Nullable<number | string>;
+    oom_disabled: boolean;
+    oom_killer: boolean;
+};
+type FeatureLimits = {
+    databases: number;
+    allocations: number;
+    backups: number;
+};
+
+type Container = {
+    startup_command: string;
+    image: string;
+    installed: number;
+    environment: {
+        [key: string]: string | number;
+    };
+    ports: number[];
+    volumes: string[];
+    network_mode: string;
+};
+
+type Server$1 = {
+    id: number;
+    external_id: string | null;
+    uuid: string;
+    identifier: string;
+    name: string;
+    description: string;
+    status: any | null;
+    suspended: boolean;
+    limits: ServerLimits;
+    feature_limits: FeatureLimits;
+    user: number;
+    node: number;
+    allocation: number;
+    nest: number;
+    egg: number;
+    container: Container;
+    created_at: string;
+    updated_at: string | null;
+};
+
+type Allocation = {
+    id: number;
+    ip: string;
+    ip_alias: Nullable<string>;
+    port: number;
+    notes: Nullable<string>;
+    is_default: boolean;
+};
+
+type Server = {
+    server_owner: boolean;
+    identifier: string;
+    internal_id?: number;
+    uuid: string;
+    name: string;
+    node: string;
+    is_node_under_maintenance: boolean;
+    sftp_details: {
+        ip: string;
+        alias: Nullable<string>;
+        port: number;
+    };
+    description: string;
+    limits: ServerLimits;
+    invocation: string;
+    docker_image: string;
+    egg_features: string[] | null;
+    feature_limits: FeatureLimits;
+    status: Nullable<unknown>;
+    is_suspended: boolean;
+    is_installing: boolean;
+    is_transferring: boolean;
+    relationships: {
+        allocations: GenericListResponse<GenericResponse<Allocation, "allocation">>;
+        variables: GenericListResponse<GenericResponse<EggVariable, "egg_variable">>;
+        egg?: GenericResponse<{
+            uuid: string;
+            name: string;
+        }, "egg">;
+        subusers: GenericListResponse<GenericResponse<ServerSubuser, "server_subuser">>;
+    };
+};
+type ServerStats = {
+    current_state: "installing" | "install_failed" | "reinstall_failed" | "suspended" | "restoring_backup" | "running" | "stopped" | "offline";
+    is_suspended: boolean;
+    resources: ServerResources;
+};
+type ServerResources = {
+    memory_bytes: number;
+    cpu_absolute: number;
+    disk_bytes: number;
+    network_tx_bytes: number;
+    network_rx_bytes: number;
+    uptime: number;
+};
+type ServerActivityLog = {
+    id: string;
+    event: string;
+    is_api: boolean;
+    ip: string;
+    description: Nullable<string>;
+    properties: Record<string, string>;
+    has_additional_metadata: boolean;
+    timestamp: string;
+};
+
+type Database = {
+    id: string;
+    host: {
+        address: string;
+        port: number;
+    };
+    name: string;
+    username: string;
+    connections_from: string;
+    max_connections: number;
+    relationships?: {
+        password: GenericResponse<{
+            password: string;
+        }, "database_password">;
+    };
+};
+
+declare class ServerDatabases {
+    private readonly r;
+    private readonly id;
+    constructor(requester: AxiosInstance, id: string);
+    list: (include?: ("password")[], page?: number) => Promise<Database[]>;
+    create: (database: string, remote: string) => Promise<Database>;
+    rotatePassword: (database_id: string) => Promise<Database>;
+    delete: (database_id: string) => Promise<void>;
+}
+
+type FileObject = {
+    name: string;
+    mode: string;
+    mode_bits: string;
+    size: number;
+    is_file: boolean;
+    is_symlink: boolean;
+    mimetype: string;
+    created_at: string;
+    modified_at: string;
+};
+
+declare class ServerFiles {
+    private readonly r;
+    private readonly id;
+    constructor(requester: AxiosInstance, id: string);
+    list: (path?: string) => Promise<FileObject[]>;
+    /**
+     * Return the contents of a file. To read binary file (non-editable) use {@link download} instead
+     */
+    contents: (path: string) => Promise<string>;
+    downloadGetUrl: (path: string) => Promise<string>;
+    download: (path: string) => Promise<ArrayBuffer>;
+    rename: (root: string | undefined, files: {
+        from: string;
+        to: string;
+    }[]) => Promise<void>;
+    copy: (location: string) => Promise<void>;
+    write: (path: string, content: string) => Promise<void>;
+    compress: (root: string | undefined, files: string[], archive_name?: string, extension?: "zip" | "tgz" | "tar.gz" | "txz" | "tar.xz" | "tbz2" | "tar.bz2") => Promise<void>;
+    decompress: (root: string | undefined, file: string) => Promise<void>;
+    delete: (root: string | undefined, files: string[]) => Promise<void>;
+    createFolder: (root: string | undefined, name: string) => Promise<void>;
+    chmod: (root: string | undefined, files: Array<{
+        file: string;
+        mode: number;
+    }>) => Promise<void>;
+    pullFromRemote: (url: string, directory?: string, filename?: string, // Unused
+    use_header?: boolean, // Unused
+    foreground?: boolean) => Promise<void>;
+    uploadGetUrl: () => Promise<string>;
+    upload: (file: File, root?: string) => Promise<void>;
+}
+
+type Schedule = {
+    id: number;
+    name: string;
+    cron: {
+        day_of_week: string;
+        day_of_month: string;
+        hour: string;
+        minute: string;
+    };
+    is_active: boolean;
+    is_processing: boolean;
+    only_when_online: boolean;
+    last_run_at: Nullable<string>;
+    next_run_at: string;
+    created_at: string;
+    updated_at: string;
+    relationships: {
+        tasks: GenericListResponse<GenericResponse<ScheduleTask, "schedule_task">>;
+    };
+};
+type ScheduleTask = {
+    id: number;
+    sequence_id: number;
+    action: "command" | "power" | "backup" | "delete_files";
+    payload: string;
+    time_offset: number;
+    is_queued: boolean;
+    continue_on_failure: boolean;
+    created_at: string;
+    updated_at: Nullable<string>;
+};
+
+declare class ServerSchedules {
+    private readonly r;
+    private readonly id;
+    constructor(requester: AxiosInstance, id: string);
+    list: () => Promise<Schedule[]>;
+    create: (params: ScheduleCreateParams) => Promise<Schedule>;
+    control: (sched_id: number) => ScheduleControl;
+}
+type ScheduleCreateParams = {
+    name: string;
+    is_active?: boolean;
+    only_when_online?: boolean;
+    minute: string;
+    hour: string;
+    day_of_week: string;
+    month: string;
+    day_of_month: string;
+};
+declare class ScheduleControl {
+    private r;
+    private readonly id;
+    private readonly sched_id;
+    constructor(requester: AxiosInstance, id: string, sched_id: number);
+    info: () => Promise<Schedule>;
+    update: (params: ScheduleCreateParams) => Promise<Schedule>;
+    delete: () => Promise<void>;
+    execute: () => Promise<void>;
+    tasks: {
+        create: (opts: PartialBy<Pick<ScheduleTask, "action" | "payload" | "time_offset" | "sequence_id" | "continue_on_failure">, "payload" | "sequence_id" | "continue_on_failure">) => Promise<ScheduleTask>;
+        update: <T extends "command" | "power" | "backup" | "delete_files">(task_id: number, opts: PartialBy<Pick<ScheduleTask, "action" | "payload" | "time_offset" | "sequence_id" | "continue_on_failure">, "payload" | "sequence_id" | "continue_on_failure">) => Promise<ScheduleTask>;
+        delete: (task_id: number) => Promise<void>;
+    };
+}
+
+declare class ServerAllocations {
+    private readonly r;
+    private readonly id;
+    constructor(requester: AxiosInstance, id: string);
+    list: () => Promise<Allocation[]>;
+    autoAssign: () => Promise<Allocation>;
+    setNotes: (alloc_id: number, notes: string) => Promise<Allocation>;
+    setPrimary: (alloc_id: number) => Promise<Allocation>;
+    unassign: (alloc_id: number) => Promise<void>;
+}
+
+declare class ServerUsers {
+    private readonly r;
+    private readonly id;
+    constructor(requester: AxiosInstance, id: string);
+    list: () => Promise<ServerSubuser[]>;
+    create: (email: string, permissions: SubuserPermission[] | string[]) => Promise<ServerSubuser>;
+    info: (user_id: number) => Promise<ServerSubuser>;
+    update: (user_id: number, permissions: SubuserPermission[] | string[]) => Promise<ServerSubuser>;
+    delete: (user_id: number) => Promise<void>;
+}
+
+type Backup = {
+    uuid: string;
+    is_successful: boolean;
+    is_locked: boolean;
+    name: string;
+    ignored_files: string[];
+    checksum: Nullable<string>;
+    bytes: number;
+    created_at: string;
+    completed_at: Nullable<string>;
+};
+
+declare class ServerBackups {
+    private readonly r;
+    private readonly id;
+    constructor(requester: AxiosInstance, id: string);
+    list: (page?: number) => Promise<Backup[]>;
+    create: (args: {
+        name?: string;
+        is_locked: boolean;
+        ignored_files: string[];
+    }) => Promise<Backup>;
+    info: (backup_uuid: string) => Promise<Backup>;
+    downloadGetUrl: (backup_uuid: string) => Promise<string>;
+    download: (backup_uuid: string) => Promise<ArrayBuffer>;
+    delete: (backup_uuid: string) => Promise<void>;
+}
+
+type StartupParams = {
+    name: string;
+    description: string;
+    env_variables: string;
+    default_value: string;
+    server_value: string;
+    is_editable: boolean;
+    rules: string;
+};
+type StartupMeta = {
+    startup_command: string;
+    raw_startup_command: string;
+};
+
+declare class ServerStartup {
+    private readonly r;
+    private readonly id;
+    constructor(requester: AxiosInstance, id: string);
+    list: () => Promise<CustomListResponse<StartupParams, StartupMeta>>;
+    set: (key: string, value: string) => Promise<StartupParams>;
+}
+
+declare class ServerSettings {
+    private readonly r;
+    private readonly id;
+    constructor(requester: AxiosInstance, id: string);
+    rename: (name: string) => Promise<void>;
+    updateDescription: (description: Nullable<string>) => Promise<void>;
+    reinstall: () => Promise<void>;
+    changeDockerImage: (image: string) => Promise<void>;
+}
+
+/**
+ * Source: https://github.com/pterodactyl/panel/blob/1.0-develop/resources/scripts/components/server/events.ts
+ */
+declare enum SOCKET_EVENT {
+    AUTH_SUCCESS = "auth success",
+    DAEMON_MESSAGE = "daemon message",
+    DAEMON_ERROR = "daemon error",
+    INSTALL_OUTPUT = "install output",
+    INSTALL_STARTED = "install started",
+    INSTALL_COMPLETED = "install completed",
+    CONSOLE_OUTPUT = "console output",
+    STATUS = "status",
+    STATS = "stats",
+    TRANSFER_LOGS = "transfer logs",
+    TRANSFER_STATUS = "transfer status",
+    BACKUP_COMPLETED = "backup completed",
+    BACKUP_RESTORE_COMPLETED = "backup restore completed",
+    TOKEN_EXPIRING = "token expiring",
+    TOKEN_EXPIRED = "token expired",
+    JWT_ERROR = "jwt error"
+}
+type BackupCompletedJson = {
+    checksum: string;
+    checksum_type: 'sha1';
+    file_size: number;
+    is_successful: boolean;
+    uuid: string;
+};
+type PowerState = 'starting' | 'stopping' | 'running' | 'offline';
+type StatsWsJson = {
+    memory_bytes: number;
+    memory_limit_bytes: number;
+    cpu_absolute: number;
+    network: {
+        rx_bytes: number;
+        tx_bytes: number;
+    };
+    state: PowerState;
+    uptime: number;
+    disk_bytes: number;
+};
+
+type ServerSignalOption = 'start' | 'stop' | 'restart' | 'kill';
+
+type SocketEventPayloadMap = {
+    [SOCKET_EVENT.AUTH_SUCCESS]: undefined;
+    [SOCKET_EVENT.STATUS]: PowerState;
+    [SOCKET_EVENT.CONSOLE_OUTPUT]: string;
+    [SOCKET_EVENT.STATS]: StatsWsJson;
+    [SOCKET_EVENT.DAEMON_ERROR]: undefined;
+    [SOCKET_EVENT.DAEMON_MESSAGE]: string;
+    [SOCKET_EVENT.INSTALL_OUTPUT]: string;
+    [SOCKET_EVENT.INSTALL_STARTED]: undefined;
+    [SOCKET_EVENT.INSTALL_COMPLETED]: undefined;
+    [SOCKET_EVENT.TRANSFER_LOGS]: string;
+    [SOCKET_EVENT.TRANSFER_STATUS]: string;
+    [SOCKET_EVENT.BACKUP_COMPLETED]: BackupCompletedJson;
+    [SOCKET_EVENT.BACKUP_RESTORE_COMPLETED]: undefined;
+    [SOCKET_EVENT.TOKEN_EXPIRING]: undefined;
+    [SOCKET_EVENT.TOKEN_EXPIRED]: undefined;
+    [SOCKET_EVENT.JWT_ERROR]: string;
+};
+type Listener<E extends SOCKET_EVENT> = SocketEventPayloadMap[E] extends undefined ? () => void : (payload: SocketEventPayloadMap[E]) => void;
+type CloseEventLike = Parameters<NonNullable<WebSocket["onclose"]>>[0];
+type ErrorEventLike = Parameters<NonNullable<WebSocket["onerror"]>>[0];
+declare class ServerWebsocket {
+    private readonly r;
+    private readonly serverId;
+    private socket?;
+    private currentToken?;
+    private readonly bus;
+    private debugLogging;
+    private stripColors;
+    private detachMessageListener?;
+    constructor(requester: AxiosInstance, id: string, stripColors?: boolean);
+    on<E extends SOCKET_EVENT>(event: E, listener: Listener<E>): () => void;
+    deregister<E extends SOCKET_EVENT>(event: E, listener: Listener<E>): void;
+    private emit;
+    connect(resumable?: boolean, debugLogging?: boolean): Promise<void>;
+    onSocketDisconnect(handler: (event: CloseEventLike) => void): void;
+    onSocketError(handler: (event: ErrorEventLike) => void): void;
+    makeResumable(disconnectsToo: boolean): void;
+    private attachMessageListener;
+    private handleIncomingMessage;
+    private parseMessage;
+    private normalisePayload;
+    private dispatchMessage;
+    private refreshCredentials;
+    private authenticate;
+    disconnect(): void;
+    requestStats(): void;
+    requestLogs(): void;
+    private send;
+    getStats(): Promise<StatsWsJson>;
+    getLogs(): Promise<string[]>;
+    sendPoweraction(action: ServerSignalOption): void;
+    sendCommand(cmd: string): void;
+}
+
+declare class ServerActivity {
+    private readonly r;
+    private readonly id;
+    constructor(r: AxiosInstance, id: string);
+    list: (page?: number, per_page?: number) => Promise<ServerActivityLog[]>;
+}
+
+declare class ServerClient {
+    private readonly r;
+    private readonly id;
+    activity: ServerActivity;
+    databases: ServerDatabases;
+    files: ServerFiles;
+    schedules: ServerSchedules;
+    allocations: ServerAllocations;
+    users: ServerUsers;
+    backups: ServerBackups;
+    startup: ServerStartup;
+    variables: ServerStartup;
+    settings: ServerSettings;
+    constructor(requester: AxiosInstance, id: string);
+    info: (include?: ("egg" | "subusers")[]) => Promise<Server>;
+    websocket: (stripColors?: boolean) => ServerWebsocket;
+    resources: () => Promise<ServerStats>;
+    command: (command: string) => Promise<void>;
+    power: (signal: "start" | "stop" | "restart" | "kill") => Promise<void>;
+}
+
+declare class Client$1 {
+    account: Account;
+    private readonly r;
+    constructor(requester: AxiosInstance);
+    listPermissions: () => Promise<Record<string, Permission>>;
+    listServers: (type?: "accessible" | "mine" | "admin" | "admin-all", page?: number, per_page?: number, include?: ("egg" | "subusers")[]) => Promise<Server[]>;
+    server: (uuid: string) => ServerClient;
+}
+
+type User = {
+    id: number;
+    external_id: string | null;
+    uuid: string;
+    username: string;
+    email: string;
+    first_name: string;
+    last_name: string;
+    language: string;
+    root_admin: string;
+    "2fa": boolean;
+    created_at: string;
+    updated_at: string;
+    relationships?: {
+        servers: GenericListResponse<GenericResponse<Server$1>>;
+    };
+};
+
+declare class Users {
+    private readonly r;
+    constructor(requester: AxiosInstance);
+    list: ({ ...opts }: ListType, page?: number) => Promise<User[]>;
+    info: (id: number, { include }: {
+        include?: ("servers")[];
+    }) => Promise<User>;
+    infoByExternal: (external_id: string, { include }: {
+        include?: ("servers")[];
+    }) => Promise<User>;
+    create: (user: CreateType) => Promise<User>;
+    update: (id: number, user: UpdateType) => Promise<User>;
+    delete: (id: number) => Promise<void>;
+}
+type ListType = {
+    include?: ("servers")[];
+    filters?: ListFilters;
+    sort?: ListSort;
+};
+type ListFilters = {
+    [key in "email" | "uuid" | "username" | "external_id"]: string;
+};
+type ListSort = ExactlyOneKey<"id" | "uuid", "asc" | "desc">;
+type CreateType = {
+    email: string;
+    username: string;
+    first_name: string;
+    last_name: string;
+};
+type UpdateType = CreateType & {
+    language: string;
+    password: string;
+};
+
+declare class Client {
+    private readonly r;
+    users: Users;
+    constructor(requester: AxiosInstance);
+}
+
+declare class PelicanClient extends Client$1 {
+    constructor(url: string, token: string);
+}
+declare class PelicanApplication extends Client {
+    constructor(url: string, token: string);
+}
+
+export { PelicanApplication, PelicanClient };