@pelican.ts/sdk/dist/index.d.mts

Pelican panel SDK for TypeScript

import { AxiosInstance } from 'axios';
import WebSocket from 'isomorphic-ws';

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;
};

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 ServerDatabase$1 = {
    id: string;
    host: {
        address: string;
        port: number;
    };
    name: string;
    username: string;
    connections_from: string;
    max_connections: number;
    relationships?: {
        password: GenericResponse<{
            password: string;
        }, "database_password">;
    };
};

type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
type Nullable<T> = T | null;

type ServerBackup$1 = {
    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>;
};

type ServerSignalOption = "start" | "stop" | "restart" | "kill";

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 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;
};

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>;
};

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 ServerAllocation$1 = {
    id: number;
    ip: string;
    ip_alias: Nullable<string>;
    port: number;
    notes: Nullable<string>;
    is_default: boolean;
};

type Server$1 = {
    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: Nullable<string[]>;
    feature_limits: FeatureLimits;
    status: Nullable<unknown>;
    is_suspended: boolean;
    is_installing: boolean;
    is_transferring: boolean;
    relationships: {
        allocations: GenericListResponse<GenericResponse<ServerAllocation$1, "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 User = {
    uuid: string;
    username: string;
    email: string;
    language: string;
    image: string;
    admin: boolean;
    root_admin: boolean;
    "2fa_enabled": boolean;
    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>;
};

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;
}

/**
 * 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;
};

declare class Account$1 {
    private readonly r;
    constructor(requester: AxiosInstance);
    info: () => Promise<User>;
    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>;
    };
}

declare class ServerDatabases {
    private readonly r;
    private readonly id;
    constructor(requester: AxiosInstance, id: string);
    list: (include?: "password"[], page?: number) => Promise<ServerDatabase$1[]>;
    create: (database: string, remote: string) => Promise<ServerDatabase$1>;
    rotatePassword: (database_id: string) => Promise<ServerDatabase$1>;
    delete: (database_id: string) => Promise<void>;
}

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<FileObject>;
    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>;
}

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<ServerAllocation$1[]>;
    autoAssign: () => Promise<ServerAllocation$1>;
    setNotes: (alloc_id: number, notes: string) => Promise<ServerAllocation$1>;
    setPrimary: (alloc_id: number) => Promise<ServerAllocation$1>;
    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_uuid: string) => Promise<ServerSubuser>;
    update: (user_uuid: string, permissions: SubuserPermission[] | string[]) => Promise<ServerSubuser>;
    delete: (user_uuid: string) => Promise<void>;
}

declare class ServerBackups {
    private readonly r;
    private readonly id;
    constructor(requester: AxiosInstance, id: string);
    list: (page?: number) => Promise<ServerBackup$1[]>;
    create: (args: {
        name?: string;
        is_locked: boolean;
        ignored_files: string[];
    }) => Promise<ServerBackup$1>;
    info: (backup_uuid: string) => Promise<ServerBackup$1>;
    downloadGetUrl: (backup_uuid: string) => Promise<string>;
    download: (backup_uuid: string) => Promise<ArrayBuffer>;
    delete: (backup_uuid: string) => Promise<void>;
    rename: (backup_uuid: string, name: string) => Promise<void>;
    toggleLock: (backup_uuid: string) => Promise<void>;
    restore: (backup_uuid: string, truncate: boolean) => Promise<void>;
}

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>;
}

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$1>;
    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$1;
    private readonly r;
    constructor(requester: AxiosInstance);
    get $r(): AxiosInstance;
    listPermissions: () => Promise<Record<string, Permission>>;
    listServers: (type?: "accessible" | "mine" | "admin" | "admin-all", page?: number, per_page?: number, include?: ("egg" | "subusers")[]) => Promise<Server$1[]>;
    server: (uuid: string) => ServerClient;
}

declare class Account {
    private readonly client;
    readonly uuid: string;
    readonly username: string;
    private $email;
    get email(): string;
    readonly language: string;
    readonly image: string;
    readonly admin: boolean;
    readonly root_admin: boolean;
    private $has2faEnabled;
    get has2faEnabled(): boolean;
    readonly createdAt: Date;
    readonly updatedAt: Date;
    constructor(client: Client$1, user: User);
    updateEmail: (newEmail: string, password: string) => Promise<void>;
    updatePassword: (newPassword: string) => Promise<void>;
    listApiKeys: () => Promise<APIKey[]>;
    createApiKey: (description: string, allowed_ips?: string[]) => Promise<APIKey & {
        secret_token: string;
    }>;
    deleteApiKey: (identifier: string) => Promise<void>;
    listSshKeys: () => Promise<SSHKey[]>;
    createSshKey: (name: string, public_key: string) => Promise<SSHKey>;
    deleteSshKey: (fingerprint: string) => Promise<void>;
}

declare class ServerAllocation {
    private readonly client;
    readonly alias: Nullable<string>;
    readonly id: number;
    readonly ip: string;
    private $isDefault;
    get isDefault(): boolean;
    private $notes;
    get notes(): Nullable<string>;
    readonly port: number;
    constructor(client: ServerClient, alloc: ServerAllocation$1);
    setNotes: (notes: string) => Promise<void>;
    makeDefault: () => Promise<void>;
    unassign: () => Promise<void>;
}

declare class ServerBackup {
    private readonly client;
    readonly bytes: number;
    readonly checksum: Nullable<string>;
    readonly completedAt: Nullable<Date>;
    readonly createdAt: Date;
    readonly ignoredFiles: string[];
    readonly isLocked: boolean;
    readonly isSuccessful: boolean;
    readonly name: string;
    readonly uuid: string;
    constructor(client: ServerClient, backup: ServerBackup$1);
    downloadGetUrl: () => Promise<string>;
    download: () => Promise<ArrayBuffer>;
    delete: () => Promise<void>;
    rename: (name: string) => Promise<void>;
    toggleLock: () => Promise<void>;
    restore: (truncate: boolean) => Promise<void>;
}

declare class ServerDatabase {
    private readonly client;
    readonly allowConnectionsFrom: string;
    readonly host: string;
    readonly port: number;
    readonly id: string;
    readonly maxConnections: number;
    readonly name: string;
    private $password?;
    get password(): string | undefined;
    readonly username: string;
    constructor(client: ServerClient, database: ServerDatabase$1);
    rotatePassword: () => Promise<void>;
    delete: () => Promise<void>;
}

declare class ServerFile {
    private readonly client;
    private readonly dir;
    private readonly path;
    readonly createdAt: Date;
    readonly isFile: boolean;
    readonly isSymlink: boolean;
    readonly mimetype: string;
    readonly mode: string;
    readonly modeBits: string;
    readonly modifiedAt: Date;
    readonly name: string;
    readonly size: number;
    constructor(client: ServerClient, file: FileObject, dir?: string);
    get isArchive(): boolean;
    /**
     * Return the contents of a file. To read binary file (non-editable) use {@link download} instead
     */
    contents: () => Promise<string>;
    downloadGetUrl: () => Promise<string>;
    download: () => Promise<ArrayBuffer>;
    rename: (newName: string) => Promise<void>;
    copy: () => Promise<void>;
    write: (content: string) => Promise<void>;
    compress: (archive_name?: string, extension?: "zip" | "tgz" | "tar.gz" | "txz" | "tar.xz" | "tbz2" | "tar.bz2") => Promise<ServerFile>;
    decompress: () => Promise<void>;
    delete: () => Promise<void>;
    chmod: (mode: number) => Promise<void>;
}

declare class ServerSchedule {
    private readonly client;
    readonly createdAt: Date;
    private $cron;
    get cron(): {
        day_of_week: string;
        day_of_month: string;
        hour: string;
        minute: string;
    };
    readonly id: number;
    private $isActive;
    get isActive(): boolean;
    private $isProcessing;
    get isProcessing(): boolean;
    readonly lastRunAt: Nullable<Date>;
    private $name;
    get name(): string;
    readonly nextRunAt: Date;
    private $onlyWhenOnline;
    get onlyWhenOnline(): boolean;
    readonly tasks: ServerScheduleTask[];
    private $updatedAt;
    get updatedAt(): Date;
    constructor(client: ServerClient, schedule: Schedule);
    update: (opts: {
        name: string;
        is_active?: boolean;
        only_when_online?: boolean;
        minute: string;
        hour: string;
        day_of_week: string;
        month: string;
        day_of_month: string;
    }) => Promise<void>;
    delete: () => Promise<void>;
    execute: () => Promise<void>;
}
declare class ServerScheduleTask {
    private readonly client;
    private readonly scheduleId;
    private $action;
    get action(): "command" | "power" | "backup" | "delete_files";
    private $continueOnFailure;
    get continueOnFailure(): boolean;
    readonly createdAt: Date;
    readonly id: number;
    private $isQueued;
    get isQueued(): boolean;
    private $payload;
    get payload(): string;
    private $sequenceId;
    get sequenceId(): number;
    private $timeOffset;
    get timeOffset(): number;
    private $updatedAt;
    get updatedAt(): Nullable<Date>;
    constructor(client: ServerClient, scheduleId: number, task: ScheduleTask);
    delete: () => Promise<void>;
    update: (opts: PartialBy<Pick<ScheduleTask, "action" | "payload" | "time_offset" | "sequence_id" | "continue_on_failure">, "payload" | "sequence_id" | "continue_on_failure">) => Promise<void>;
}

declare class ServerUser {
    private readonly client;
    readonly uuid: string;
    readonly username: string;
    readonly email: string;
    readonly language: string;
    readonly image: string;
    readonly admin: boolean;
    readonly root_admin: boolean;
    readonly has2faEnabled: boolean;
    readonly createdAt: Date;
    private $permissions;
    get permissions(): string[] | SubuserPermission[];
    constructor(client: ServerClient, user: ServerSubuser);
    update: (permissions: SubuserPermission[] | string[]) => Promise<void>;
    delete: () => Promise<void>;
}

declare class Server {
    private readonly client;
    readonly ownsServer: boolean;
    readonly identifier: string;
    readonly internalId?: number;
    readonly uuid: string;
    private $name;
    get name(): string;
    readonly node: string;
    readonly isNodeUnderMaintenance: boolean;
    readonly sftp: {
        ip: string;
        alias: Nullable<string>;
        port: number;
    };
    private $description;
    get description(): string;
    readonly limits: ServerLimits;
    readonly invocation: string;
    private $dockerImage;
    get dockerImage(): string;
    readonly eggFeatures: Nullable<string[]>;
    readonly featureLimits: FeatureLimits;
    readonly status: unknown;
    readonly isSuspended: boolean;
    readonly isInstalling: boolean;
    readonly isTransferring: boolean;
    readonly allocations: ServerAllocation[];
    readonly variables: EggVariable[];
    readonly egg?: {
        uuid: string;
        name: string;
    };
    readonly subusers?: ServerUser[];
    constructor(client: ServerClient, server: Server$1);
    rename: (name: string) => Promise<void>;
    updateDescription: (description: string) => Promise<void>;
    reinstall: () => Promise<void>;
    changeDockerImage: (image: string) => Promise<void>;
    getActivityLogs: (opts?: {
        page?: number;
        per_page?: number;
    }) => Promise<ServerActivityLog[]>;
    websocket: (stripColors?: boolean) => ServerWebsocket;
    getServerStats: () => Promise<ServerStats>;
    runCommand: (command: string) => Promise<void>;
    sendPowerSignal: (signal: "start" | "stop" | "restart" | "kill") => Promise<void>;
    getDatabases: (opts?: {
        include?: "password"[];
        page?: number;
    }) => Promise<ServerDatabase[]>;
    createDatabase: (database: string, remote: string) => Promise<ServerDatabase>;
    getSchedules: () => Promise<ServerSchedule[]>;
    createSchedule: (...opts: Parameters<ServerSchedules["create"]>) => Promise<ServerSchedule>;
    getBackups: (page?: number) => Promise<ServerBackup[]>;
    createBackup: (...args: Parameters<ServerBackups["create"]>) => Promise<ServerBackup>;
    getAllocations: () => Promise<ServerAllocation[]>;
    createAllocation: () => Promise<ServerAllocation>;
    getFiles: (path?: string) => Promise<ServerFile[]>;
    createFolder: (...opts: Parameters<ServerFiles["createFolder"]>) => Promise<void>;
    uploadFile: (...opts: Parameters<ServerFiles["upload"]>) => Promise<void>;
    uploadFileGetUrl: (...opts: Parameters<ServerFiles["uploadGetUrl"]>) => Promise<string>;
    pullFileFromRemote: (...opts: Parameters<ServerFiles["pullFromRemote"]>) => Promise<void>;
    compressMultipleFiles: (...opts: Parameters<ServerFiles["compress"]>) => Promise<FileObject>;
    renameMultipleFiles: (...opts: Parameters<ServerFiles["rename"]>) => Promise<void>;
    deleteMultipleFiles: (...opts: Parameters<ServerFiles["delete"]>) => Promise<void>;
    getUsers: () => Promise<ServerUser[]>;
    createUser: (email: string, permissions: SubuserPermission[] | string[]) => Promise<ServerUser>;
    getStartupInfo: () => Promise<CustomListResponse<StartupParams, StartupMeta>>;
    setStartupVariable: (key: string, value: string) => Promise<StartupParams>;
}

declare class Client {
    private readonly client;
    constructor(client: Client$1);
    get $client(): Client$1;
    getAccount: () => Promise<Account>;
    listPermissions: () => Promise<Record<string, Permission>>;
    listServers: (opts?: {
        type?: "accessible" | "mine" | "admin" | "admin-all";
        page?: number;
        per_page?: number;
        include?: ("egg" | "subusers")[];
    }) => Promise<Server[]>;
    getServer: (uuid: string, include?: ("egg" | "subusers")[]) => Promise<Server>;
}

declare const createPelicanClient: (url: string, token: string, suffix?: string) => Client;

export { Account, Client, Server, ServerAllocation, ServerBackup, ServerDatabase, ServerFile, ServerSchedule, ServerUser, createPelicanClient };