import { AxiosInstance, AxiosProgressEvent } from 'axios';
import z from 'zod';
import WebSocket from 'isomorphic-ws';

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

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

/**
 * Server limits indicate how many resources can be used by the server
 */
type ServerLimits = {
    /**
     * Memory limit in megabytes, 0 = unlimited
     * @remarks
     * This is not a pterodactyl's MiB, it's a MB (multiple of 1000).
     * That means to set 8GB RAM, you should set 8000 instead of 8192
     */
    memory: number;
    /**
     * Swap limit in megabytes, 0 = disabled, -1 = unlimited
     * @see memory
     */
    swap: number;
    /**
     * Disk limit in megabytes, 0 = unlimited
     * @see memory
     */
    disk: number;
    /**
     * IO is an arbitrary value indicating IO importance relative to other servers
     */
    io: number;
    /**
     * CPU limit in percentage, 0 = unlimited (1 core = 100%)
     */
    cpu: number;
    /**
     * CPU pinning (Optional)
     * @usage
     * ```
     * 1 or 1,2,4 or 1-4
     * ```
     * @remarks
     * Can be useful to pin workloads to P-cores and avoid E-cores or HT/SMT cores
     * @see https://superuser.com/questions/122536/what-is-hyper-threading-and-how-does-it-work
     */
    threads: Nullable<number | string>;
    /**
     * If OOM killer should be disabled, opposite of {@link oom_killer}
     * @deprecated use {@link oom_killer}
     */
    oom_disabled: boolean;
    /**
     * If OOM killer should be enabled, opposite of {@link oom_disabled}
     */
    oom_killer: boolean;
};
/**
 * Feature limits indicate how many features can user enable by themselves. It doesn't include features assigned
 * by admins
 */
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 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 EggVariable = {
    name: string;
    description: string;
    env_variable: string;
    default_value: string;
    server_value: string;
    is_editable: boolean;
    rules: string;
};

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

type ServerAllocation$1 = {
    id: number;
    ip: string;
    ip_alias: Nullable<string>;
    port: number;
    notes: Nullable<string>;
    is_default: boolean;
};

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 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 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<ServerStats["current_state"]>;
    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;
    relationships?: {
        actor?: GenericResponse<User, "user"> | GenericResponse<null, "null_resource">;
    };
};

declare class Account$1 {
    private readonly r;
    constructor(requester: AxiosInstance);
    info: () => Promise<User>;
    updateEmail: (newEmail: string, password: string) => Promise<void>;
    updatePassword: (currentPassword: string, 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 ServerActivity {
    private readonly r;
    private readonly id;
    constructor(r: AxiosInstance, id: string);
    list: (page?: number, per_page?: number, opts?: {
        sortByTimestamp?: "asc" | "desc";
        includeActor?: boolean;
    }) => Promise<ServerActivityLog[]>;
}

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 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 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, opts?: {
        onUploadProgressRaw?: (progressEvent: AxiosProgressEvent) => void;
        onUploadProgressPercent?: (percent: number) => void;
    }) => Promise<void>;
}

declare const ScheduleCreateParamsSchema: z.ZodObject<{
    name: z.ZodString;
    is_active: z.ZodOptional<z.ZodBoolean>;
    only_when_online: z.ZodOptional<z.ZodBoolean>;
    minute: z.ZodString;
    hour: z.ZodString;
    day_of_week: z.ZodString;
    month: z.ZodString;
    day_of_month: z.ZodString;
}, z.core.$strip>;
type ScheduleCreateParams = z.infer<typeof ScheduleCreateParamsSchema>;
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;
}
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 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 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 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 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;
}

/**
 * Instance of a Humane Pelican User
 *
 * @class
 * @example
 * You can create account from a raw client
 * ```ts
 * import {PelicanAPIClient} from "@pelican.ts/sdk/api"
 * const client = new PelicanAPIClient(...)
 * const userData = await client.account.info()
 * const account = new Account(client, userData)
 * ```
 */
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;
    /**
     * Has currently no significance
     */
    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: (currentPassword: string, 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>;
}

/**
 * Instance of a Humane Pelican Server Allocation
 *
 * @class
 * @example
 * You can create allocation from a raw client
 * ```ts
 * import {PelicanAPIClient} from "@pelican.ts/sdk/api"
 * const client = new PelicanAPIClient(...)
 * const allocData = await client.account.server(...).allocations.list()
 * const alloc = new ServerAllocation(client, allocData[0])
 * ```
 */
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);
    /**
     * Set description for this allocation
     * @param notes
     */
    setNotes: (notes: string) => Promise<void>;
    /**
     * Make port primary
     */
    makeDefault: () => Promise<void>;
    /**
     * Remove allocation (if user is allowed to manage allocations by themselves)
     */
    unassign: () => Promise<void>;
}

/**
 * Instance of a Humane Pelican Server Backup
 *
 * @class
 * @example
 * You can create account from a raw client
 * ```ts
 * import {PelicanAPIClient} from "@pelican.ts/sdk/api"
 * const client = new PelicanAPIClient(...)
 * const backupData = await client.account.server(...).backups.info(...)
 * const backup = new ServerBackup(client, backupData)
 * ```
 */
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>;
}

/**
 * Instance of a Humane Pelican Server Database
 *
 * @class
 * @example
 * You can create account from a raw client
 * ```ts
 * import {PelicanAPIClient} from "@pelican.ts/sdk/api"
 * const client = new PelicanAPIClient(...)
 * const dbData = await client.account.server(...).databases.info(...)
 * const database = new ServerDatabase(client, dbData)
 * ```
 */
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);
    /**
     * Reset password to a random one, password will be updated in this ServerDatabase instance
     */
    rotatePassword: () => Promise<void>;
    delete: () => Promise<void>;
}

/**
 * Instance of a Humane Pelican Server File/Folder
 *
 * @class
 * @example
 * You can create account from a raw client
 * ```ts
 * import {PelicanAPIClient} from "@pelican.ts/sdk/api"
 * const client = new PelicanAPIClient(...)
 * const filesData = await client.account.server(...).files.list(FOLDER)
 * const server = new ServerFile(client, filesData[0], FOLDER)
 * ```
 */
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);
    /**
     * Is this file an archive
     *
     * @remarks
     * It uses extension check instead of mimetype as Pelican currently has some issue with mimetypes
     */
    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>;
}

/**
 * Instance of a Humane Pelican Server Schedule
 *
 * @class
 * @example
 * You can create account from a raw client
 * ```ts
 * import {PelicanAPIClient} from "@pelican.ts/sdk/api"
 * const client = new PelicanAPIClient(...)
 * const schedData = await client.account.server(...).schedules.list()
 * const server = new ServerSchedule(client, schedData[0])
 * ```
 */
declare class ServerSchedule {
    private readonly client;
    readonly createdAt: Date;
    private $cron;
    /**
     * CRON representation of schedule
     */
    get cron(): {
        day_of_week: string;
        day_of_month: string;
        hour: string;
        minute: string;
    };
    readonly id: number;
    private $isActive;
    /**
     * Is this schedule enabled
     */
    get isActive(): boolean;
    private $isProcessing;
    /**
     * Is this schedule currently running
     */
    get isProcessing(): boolean;
    readonly lastRunAt: Nullable<Date>;
    private $name;
    get name(): string;
    readonly nextRunAt: Date;
    private $onlyWhenOnline;
    /**
     * Should schedule run only if server is online
     */
    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;
    /**
     * Task action (command would likely need server to be online)
     */
    get action(): "command" | "power" | "backup" | "delete_files";
    private $continueOnFailure;
    /**
     * Should we fail on error or continue with other tasks?
     */
    get continueOnFailure(): boolean;
    readonly createdAt: Date;
    readonly id: number;
    private $isQueued;
    /**
     * Is this task queued right now?
     */
    get isQueued(): boolean;
    private $payload;
    /**
     * Whatever task should do: command to execute, power action or list of files to backup
     */
    get payload(): string;
    private $sequenceId;
    /**
     * Order of this task in defined schedule
     */
    get sequenceId(): number;
    private $timeOffset;
    /**
     * Time offset in seconds relative to schedule start time
     */
    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>;
}

/**
 * Instance of a Humane Pelican Server Subuser
 *
 * @class
 * @example
 * You can create account from a raw client
 * ```ts
 * import {PelicanAPIClient} from "@pelican.ts/sdk/api"
 * const client = new PelicanAPIClient(...)
 * const userData = await client.account.server(...).users.info(...)
 * const user = new ServerUser(client, userData)
 * ```
 */
declare class ServerUser {
    private readonly client;
    readonly uuid: string;
    readonly username: string;
    readonly email: string;
    readonly language: string;
    readonly image: string;
    readonly admin: boolean;
    /**
     * Currently unused
     * @deprecated
     */
    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>;
}

/**
 * Instance of a Humane Pelican Server
 *
 * @class
 * @example
 * You can create server from a raw client
 * ```ts
 * import {PelicanAPIClient} from "@pelican.ts/sdk/api"
 * const client = new PelicanAPIClient(...)
 * const serverData = await client.account.server(...).info()
 * const server = new Server(client, serverData)
 * ```
 */
declare class Server {
    private readonly client;
    /**
     * Whether the user owns the server
     *
     * @remarks
     * Useful for gatekeeping features from subusers
     */
    readonly ownsServer: boolean;
    readonly identifier: string;
    /**
     * ID used by Pelican Application API
     */
    readonly internalId?: number;
    readonly uuid: string;
    private $name;
    get name(): string;
    /**
     * Node name used by this server
     * @remarks
     * This is the name of the node used by this server, not the ID
     */
    readonly node: string;
    readonly isNodeUnderMaintenance: boolean;
    readonly sftp: {
        ip: string;
        alias: Nullable<string>;
        port: number;
    };
    private $description;
    get description(): string;
    readonly limits: ServerLimits;
    /**
     * It's a Startup command used to start the server
     */
    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[];
    /**
     * Egg variables
     */
    readonly variables: EggVariable[];
    /**
     * Egg used by this server, available only if request had include=egg
     */
    readonly egg?: {
        uuid: string;
        name: string;
    };
    /**
     * Server subusers, available only if request had include=subusers
     */
    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;
        sortByTimestamp?: "asc" | "desc";
        includeActor?: boolean;
    }) => 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[]>;
    /**
     * Create a database
     * @param database - optional database name (leave blank for autogenerated)
     * @param remote - allow connections from (ip, % or anything db-wise)
     *
     * @remarks
     * I have no idea why API endpoint doesn't allow to select database host
     */
    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[]>;
    /**
     * Create new allocation (if user is allowed to manage allocations by themselves)
     */
    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>;
    /**
     * Make wings agent download file or archive folder from specified URL instead of uploading directly
     */
    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[]>;
    /**
     * Create a subuser
     * @param email
     * @param permissions
     */
    createUser: (email: string, permissions: SubuserPermission[] | string[]) => Promise<ServerUser>;
    /**
     * Get server egg variables and startup commands
     */
    getStartupInfo: () => Promise<CustomListResponse<StartupParams, StartupMeta>>;
    setStartupVariable: (key: string, value: string) => Promise<StartupParams>;
}

/**
 * Pelican User Client
 *
 * @class
 * @param client Pelican API Client
 */
declare class Client {
    private readonly client;
    constructor(client: Client$1);
    /**
     * Get raw API client
     */
    get $client(): Client$1;
    /**
     * Get user account
     */
    getAccount: () => Promise<Account>;
    /**
     * Get subuser (current user) permissions
     *
     * Return data is not compatible with subusers API
     */
    listPermissions: () => Promise<Record<string, Permission>>;
    /**
     * List servers
     *
     * @param opts Filtering options (all optional)
     *
     * @remarks
     * `type` — Server access type (Default: accessible)
     *
     * Variants:
     * - `accessible` — your servers and servers you have access to as a subuser
     * - `mine` — only your servers
     * - `admin` — only servers you have admin access to (excluding yours)
     * - `admin-all` — all servers you have admin access to
     */
    listServers: (opts?: {
        type?: "accessible" | "mine" | "admin" | "admin-all";
        page?: number;
        per_page?: number;
        include?: ("egg" | "subusers")[];
    }) => Promise<Server[]>;
    /**
     * Get server by UUID
     *
     * @param uuid Server UUID
     * @param include Include additional data
     */
    getServer: (uuid: string, include?: ("egg" | "subusers")[]) => Promise<Server>;
}

/**
 * Creates a Humane Pelican User client
 * @param url Pelican Panel URL (ex: https://demo.pelican.dev)
 * @param token Pelican User Token (`pacc...`)
 * @param suffix API suffix, used if you expose api on a different path
 */
declare const createPelicanClient: (url: string, token: string, suffix?: string, timeout?: number) => Client;

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