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

Pelican panel SDK for TypeScript

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

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 PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
type Nullable<T> = T | null;

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

declare class Account {
    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>;
    };
}

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 ServerAllocation = {
    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: Nullable<string[]>;
    feature_limits: FeatureLimits;
    status: Nullable<unknown>;
    is_suspended: boolean;
    is_installing: boolean;
    is_transferring: boolean;
    relationships: {
        allocations: GenericListResponse<GenericResponse<ServerAllocation, "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 ServerDatabase = {
    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<ServerDatabase[]>;
    create: (database: string, remote: string) => Promise<ServerDatabase>;
    rotatePassword: (database_id: string) => Promise<ServerDatabase>;
    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<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>;
}

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<ServerAllocation[]>;
    autoAssign: () => Promise<ServerAllocation>;
    setNotes: (alloc_id: number, notes: string) => Promise<ServerAllocation>;
    setPrimary: (alloc_id: number) => Promise<ServerAllocation>;
    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>;
}

type ServerBackup = {
    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<ServerBackup[]>;
    create: (args: {
        name?: string;
        is_locked: boolean;
        ignored_files: string[];
    }) => Promise<ServerBackup>;
    info: (backup_uuid: string) => Promise<ServerBackup>;
    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>;
}

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);
    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[]>;
    server: (uuid: string) => ServerClient;
}

type Container = {
    startup_command: string;
    image: string;
    installed: number;
    docker_labels: Record<string, string>;
    environment: Record<string, string>;
    ports: number[];
    volumes: string[];
    network_mode: string;
};

type ApplicationServer = {
    id: number;
    external_id: Nullable<string>;
    uuid: string;
    identifier: string;
    name: string;
    description: string;
    status: Nullable<unknown>;
    suspended: boolean;
    limits: ServerLimits;
    feature_limits: FeatureLimits;
    user: number;
    node: number;
    allocation: number;
    egg: number;
    container: Container;
    created_at: string;
    updated_at: Nullable<string>;
};

type ApplicationUser = {
    id: number;
    external_id: Nullable<string>;
    uuid: string;
    username: string;
    email: string;
    language: string;
    root_admin: string;
    "2fa_enabled": boolean;
    "2fa": boolean;
    created_at: string;
    updated_at: Nullable<string>;
    relationships?: {
        servers: GenericListResponse<GenericResponse<ApplicationServer>>;
    };
};
type ApplicationUserApiKey = {
    id: number;
    user_id: number;
    key_type: 1;
    identifier: string;
    memo: string;
    allowed_ips: Array<string>;
    permissions: [];
    last_used_at: Nullable<string>;
    expires_at: Nullable<string>;
    created_at: string;
    updated_at: string;
};

declare class Users {
    private readonly r;
    constructor(requester: AxiosInstance);
    list: (opts: ListType, page?: number) => Promise<ApplicationUser[]>;
    info: (id: number, { include }: {
        include?: "servers"[];
    }) => Promise<ApplicationUser>;
    infoByExternal: (external_id: string, { include }: {
        include?: "servers"[];
    }) => Promise<ApplicationUser>;
    create: (user: z.infer<typeof CreateSchema>) => Promise<ApplicationUser>;
    update: (id: number, user: z.infer<typeof CreateSchema>) => Promise<ApplicationUser>;
    delete: (id: number) => Promise<void>;
    addRoles: (id: number, roles: number[]) => Promise<void>;
    removeRoles: (id: number, roles: number[]) => Promise<void>;
    apiKeys: {
        list: (id: number) => Promise<ApplicationUserApiKey[]>;
        create: (id: number, description: string, allowed_ips?: string[]) => Promise<ApplicationUserApiKey & {
            secret_token: string;
        }>;
        delete: (id: number, identifier: string) => 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">;
declare const CreateSchema: z.ZodObject<{
    email: z.ZodEmail;
    external_id: z.ZodOptional<z.ZodString>;
    username: z.ZodString;
    password: z.ZodOptional<z.ZodString>;
    language: z.ZodEnum<{
        id: "id";
        af: "af";
        ak: "ak";
        am: "am";
        ar: "ar";
        as: "as";
        az: "az";
        be: "be";
        bg: "bg";
        bm: "bm";
        bn: "bn";
        bo: "bo";
        br: "br";
        bs: "bs";
        ca: "ca";
        ce: "ce";
        cs: "cs";
        cv: "cv";
        cy: "cy";
        da: "da";
        de: "de";
        dz: "dz";
        ee: "ee";
        el: "el";
        en: "en";
        eo: "eo";
        es: "es";
        et: "et";
        eu: "eu";
        fa: "fa";
        ff: "ff";
        fi: "fi";
        fo: "fo";
        fr: "fr";
        fy: "fy";
        ga: "ga";
        gd: "gd";
        gl: "gl";
        gu: "gu";
        gv: "gv";
        ha: "ha";
        he: "he";
        hi: "hi";
        hr: "hr";
        hu: "hu";
        hy: "hy";
        ia: "ia";
        ig: "ig";
        ii: "ii";
        is: "is";
        it: "it";
        ja: "ja";
        jv: "jv";
        ka: "ka";
        ki: "ki";
        kk: "kk";
        kl: "kl";
        km: "km";
        kn: "kn";
        ko: "ko";
        ks: "ks";
        ku: "ku";
        kw: "kw";
        ky: "ky";
        lb: "lb";
        lg: "lg";
        ln: "ln";
        lo: "lo";
        lt: "lt";
        lu: "lu";
        lv: "lv";
        mg: "mg";
        mi: "mi";
        mk: "mk";
        ml: "ml";
        mn: "mn";
        mr: "mr";
        ms: "ms";
        mt: "mt";
        my: "my";
        nb: "nb";
        nd: "nd";
        ne: "ne";
        nl: "nl";
        nn: "nn";
        no: "no";
        om: "om";
        or: "or";
        os: "os";
        pa: "pa";
        pl: "pl";
        ps: "ps";
        pt: "pt";
        qu: "qu";
        rm: "rm";
        rn: "rn";
        ro: "ro";
        ru: "ru";
        rw: "rw";
        sa: "sa";
        sc: "sc";
        sd: "sd";
        se: "se";
        sg: "sg";
        si: "si";
        sk: "sk";
        sl: "sl";
        sn: "sn";
        so: "so";
        sq: "sq";
        sr: "sr";
        su: "su";
        sv: "sv";
        sw: "sw";
        ta: "ta";
        te: "te";
        tg: "tg";
        th: "th";
        ti: "ti";
        tk: "tk";
        to: "to";
        tr: "tr";
        tt: "tt";
        ug: "ug";
        uk: "uk";
        ur: "ur";
        uz: "uz";
        vi: "vi";
        wo: "wo";
        xh: "xh";
        yi: "yi";
        yo: "yo";
        zh: "zh";
        zu: "zu";
    }>;
    timezone: z.ZodEnum<{
        "Africa/Abidjan": "Africa/Abidjan";
        "Africa/Accra": "Africa/Accra";
        "Africa/Addis_Ababa": "Africa/Addis_Ababa";
        "Africa/Algiers": "Africa/Algiers";
        "Africa/Asmara": "Africa/Asmara";
        "Africa/Bamako": "Africa/Bamako";
        "Africa/Bangui": "Africa/Bangui";
        "Africa/Banjul": "Africa/Banjul";
        "Africa/Bissau": "Africa/Bissau";
        "Africa/Blantyre": "Africa/Blantyre";
        "Africa/Brazzaville": "Africa/Brazzaville";
        "Africa/Bujumbura": "Africa/Bujumbura";
        "Africa/Cairo": "Africa/Cairo";
        "Africa/Casablanca": "Africa/Casablanca";
        "Africa/Ceuta": "Africa/Ceuta";
        "Africa/Conakry": "Africa/Conakry";
        "Africa/Dakar": "Africa/Dakar";
        "Africa/Dar_es_Salaam": "Africa/Dar_es_Salaam";
        "Africa/Djibouti": "Africa/Djibouti";
        "Africa/Douala": "Africa/Douala";
        "Africa/El_Aaiun": "Africa/El_Aaiun";
        "Africa/Freetown": "Africa/Freetown";
        "Africa/Gaborone": "Africa/Gaborone";
        "Africa/Harare": "Africa/Harare";
        "Africa/Johannesburg": "Africa/Johannesburg";
        "Africa/Juba": "Africa/Juba";
        "Africa/Kampala": "Africa/Kampala";
        "Africa/Khartoum": "Africa/Khartoum";
        "Africa/Kigali": "Africa/Kigali";
        "Africa/Kinshasa": "Africa/Kinshasa";
        "Africa/Lagos": "Africa/Lagos";
        "Africa/Libreville": "Africa/Libreville";
        "Africa/Lome": "Africa/Lome";
        "Africa/Luanda": "Africa/Luanda";
        "Africa/Lubumbashi": "Africa/Lubumbashi";
        "Africa/Lusaka": "Africa/Lusaka";
        "Africa/Malabo": "Africa/Malabo";
        "Africa/Maputo": "Africa/Maputo";
        "Africa/Maseru": "Africa/Maseru";
        "Africa/Mbabane": "Africa/Mbabane";
        "Africa/Mogadishu": "Africa/Mogadishu";
        "Africa/Monrovia": "Africa/Monrovia";
        "Africa/Nairobi": "Africa/Nairobi";
        "Africa/Ndjamena": "Africa/Ndjamena";
        "Africa/Niamey": "Africa/Niamey";
        "Africa/Nouakchott": "Africa/Nouakchott";
        "Africa/Ouagadougou": "Africa/Ouagadougou";
        "Africa/Porto-Novo": "Africa/Porto-Novo";
        "Africa/Sao_Tome": "Africa/Sao_Tome";
        "Africa/Tripoli": "Africa/Tripoli";
        "Africa/Tunis": "Africa/Tunis";
        "Africa/Windhoek": "Africa/Windhoek";
        "America/Adak": "America/Adak";
        "America/Anchorage": "America/Anchorage";
        "America/Anguilla": "America/Anguilla";
        "America/Antigua": "America/Antigua";
        "America/Araguaina": "America/Araguaina";
        "America/Argentina/Buenos_Aires": "America/Argentina/Buenos_Aires";
        "America/Argentina/Catamarca": "America/Argentina/Catamarca";
        "America/Argentina/Cordoba": "America/Argentina/Cordoba";
        "America/Argentina/Jujuy": "America/Argentina/Jujuy";
        "America/Argentina/La_Rioja": "America/Argentina/La_Rioja";
        "America/Argentina/Mendoza": "America/Argentina/Mendoza";
        "America/Argentina/Rio_Gallegos": "America/Argentina/Rio_Gallegos";
        "America/Argentina/Salta": "America/Argentina/Salta";
        "America/Argentina/San_Juan": "America/Argentina/San_Juan";
        "America/Argentina/San_Luis": "America/Argentina/San_Luis";
        "America/Argentina/Tucuman": "America/Argentina/Tucuman";
        "America/Argentina/Ushuaia": "America/Argentina/Ushuaia";
        "America/Aruba": "America/Aruba";
        "America/Asuncion": "America/Asuncion";
        "America/Atikokan": "America/Atikokan";
        "America/Bahia": "America/Bahia";
        "America/Bahia_Banderas": "America/Bahia_Banderas";
        "America/Barbados": "America/Barbados";
        "America/Belem": "America/Belem";
        "America/Belize": "America/Belize";
        "America/Blanc-Sablon": "America/Blanc-Sablon";
        "America/Boa_Vista": "America/Boa_Vista";
        "America/Bogota": "America/Bogota";
        "America/Boise": "America/Boise";
        "America/Cambridge_Bay": "America/Cambridge_Bay";
        "America/Campo_Grande": "America/Campo_Grande";
        "America/Cancun": "America/Cancun";
        "America/Caracas": "America/Caracas";
        "America/Cayenne": "America/Cayenne";
        "America/Cayman": "America/Cayman";
        "America/Chicago": "America/Chicago";
        "America/Chihuahua": "America/Chihuahua";
        "America/Ciudad_Juarez": "America/Ciudad_Juarez";
        "America/Costa_Rica": "America/Costa_Rica";
        "America/Coyhaique": "America/Coyhaique";
        "America/Creston": "America/Creston";
        "America/Cuiaba": "America/Cuiaba";
        "America/Curacao": "America/Curacao";
        "America/Danmarkshavn": "America/Danmarkshavn";
        "America/Dawson": "America/Dawson";
        "America/Dawson_Creek": "America/Dawson_Creek";
        "America/Denver": "America/Denver";
        "America/Detroit": "America/Detroit";
        "America/Dominica": "America/Dominica";
        "America/Edmonton": "America/Edmonton";
        "America/Eirunepe": "America/Eirunepe";
        "America/El_Salvador": "America/El_Salvador";
        "America/Fort_Nelson": "America/Fort_Nelson";
        "America/Fortaleza": "America/Fortaleza";
        "America/Glace_Bay": "America/Glace_Bay";
        "America/Goose_Bay": "America/Goose_Bay";
        "America/Grand_Turk": "America/Grand_Turk";
        "America/Grenada": "America/Grenada";
        "America/Guadeloupe": "America/Guadeloupe";
        "America/Guatemala": "America/Guatemala";
        "America/Guayaquil": "America/Guayaquil";
        "America/Guyana": "America/Guyana";
        "America/Halifax": "America/Halifax";
        "America/Havana": "America/Havana";
        "America/Hermosillo": "America/Hermosillo";
        "America/Indiana/Indianapolis": "America/Indiana/Indianapolis";
        "America/Indiana/Knox": "America/Indiana/Knox";
        "America/Indiana/Marengo": "America/Indiana/Marengo";
        "America/Indiana/Petersburg": "America/Indiana/Petersburg";
        "America/Indiana/Tell_City": "America/Indiana/Tell_City";
        "America/Indiana/Vevay": "America/Indiana/Vevay";
        "America/Indiana/Vincennes": "America/Indiana/Vincennes";
        "America/Indiana/Winamac": "America/Indiana/Winamac";
        "America/Inuvik": "America/Inuvik";
        "America/Iqaluit": "America/Iqaluit";
        "America/Jamaica": "America/Jamaica";
        "America/Juneau": "America/Juneau";
        "America/Kentucky/Louisville": "America/Kentucky/Louisville";
        "America/Kentucky/Monticello": "America/Kentucky/Monticello";
        "America/Kralendijk": "America/Kralendijk";
        "America/La_Paz": "America/La_Paz";
        "America/Lima": "America/Lima";
        "America/Los_Angeles": "America/Los_Angeles";
        "America/Lower_Princes": "America/Lower_Princes";
        "America/Maceio": "America/Maceio";
        "America/Managua": "America/Managua";
        "America/Manaus": "America/Manaus";
        "America/Marigot": "America/Marigot";
        "America/Martinique": "America/Martinique";
        "America/Matamoros": "America/Matamoros";
        "America/Mazatlan": "America/Mazatlan";
        "America/Menominee": "America/Menominee";
        "America/Merida": "America/Merida";
        "America/Metlakatla": "America/Metlakatla";
        "America/Mexico_City": "America/Mexico_City";
        "America/Miquelon": "America/Miquelon";
        "America/Moncton": "America/Moncton";
        "America/Monterrey": "America/Monterrey";
        "America/Montevideo": "America/Montevideo";
        "America/Montserrat": "America/Montserrat";
        "America/Nassau": "America/Nassau";
        "America/New_York": "America/New_York";
        "America/Nome": "America/Nome";
        "America/Noronha": "America/Noronha";
        "America/North_Dakota/Beulah": "America/North_Dakota/Beulah";
        "America/North_Dakota/Center": "America/North_Dakota/Center";
        "America/North_Dakota/New_Salem": "America/North_Dakota/New_Salem";
        "America/Nuuk": "America/Nuuk";
        "America/Ojinaga": "America/Ojinaga";
        "America/Panama": "America/Panama";
        "America/Paramaribo": "America/Paramaribo";
        "America/Phoenix": "America/Phoenix";
        "America/Port-au-Prince": "America/Port-au-Prince";
        "America/Port_of_Spain": "America/Port_of_Spain";
        "America/Porto_Velho": "America/Porto_Velho";
        "America/Puerto_Rico": "America/Puerto_Rico";
        "America/Punta_Arenas": "America/Punta_Arenas";
        "America/Rankin_Inlet": "America/Rankin_Inlet";
        "America/Recife": "America/Recife";
        "America/Regina": "America/Regina";
        "America/Resolute": "America/Resolute";
        "America/Rio_Branco": "America/Rio_Branco";
        "America/Santarem": "America/Santarem";
        "America/Santiago": "America/Santiago";
        "America/Santo_Domingo": "America/Santo_Domingo";
        "America/Sao_Paulo": "America/Sao_Paulo";
        "America/Scoresbysund": "America/Scoresbysund";
        "America/Sitka": "America/Sitka";
        "America/St_Barthelemy": "America/St_Barthelemy";
        "America/St_Johns": "America/St_Johns";
        "America/St_Kitts": "America/St_Kitts";
        "America/St_Lucia": "America/St_Lucia";
        "America/St_Thomas": "America/St_Thomas";
        "America/St_Vincent": "America/St_Vincent";
        "America/Swift_Current": "America/Swift_Current";
        "America/Tegucigalpa": "America/Tegucigalpa";
        "America/Thule": "America/Thule";
        "America/Tijuana": "America/Tijuana";
        "America/Toronto": "America/Toronto";
        "America/Tortola": "America/Tortola";
        "America/Vancouver": "America/Vancouver";
        "America/Whitehorse": "America/Whitehorse";
        "America/Winnipeg": "America/Winnipeg";
        "America/Yakutat": "America/Yakutat";
        "Antarctica/Casey": "Antarctica/Casey";
        "Antarctica/Davis": "Antarctica/Davis";
        "Antarctica/DumontDUrville": "Antarctica/DumontDUrville";
        "Antarctica/Macquarie": "Antarctica/Macquarie";
        "Antarctica/Mawson": "Antarctica/Mawson";
        "Antarctica/McMurdo": "Antarctica/McMurdo";
        "Antarctica/Palmer": "Antarctica/Palmer";
        "Antarctica/Rothera": "Antarctica/Rothera";
        "Antarctica/Syowa": "Antarctica/Syowa";
        "Antarctica/Troll": "Antarctica/Troll";
        "Antarctica/Vostok": "Antarctica/Vostok";
        "Arctic/Longyearbyen": "Arctic/Longyearbyen";
        "Asia/Aden": "Asia/Aden";
        "Asia/Almaty": "Asia/Almaty";
        "Asia/Amman": "Asia/Amman";
        "Asia/Anadyr": "Asia/Anadyr";
        "Asia/Aqtau": "Asia/Aqtau";
        "Asia/Aqtobe": "Asia/Aqtobe";
        "Asia/Ashgabat": "Asia/Ashgabat";
        "Asia/Atyrau": "Asia/Atyrau";
        "Asia/Baghdad": "Asia/Baghdad";
        "Asia/Bahrain": "Asia/Bahrain";
        "Asia/Baku": "Asia/Baku";
        "Asia/Bangkok": "Asia/Bangkok";
        "Asia/Barnaul": "Asia/Barnaul";
        "Asia/Beirut": "Asia/Beirut";
        "Asia/Bishkek": "Asia/Bishkek";
        "Asia/Brunei": "Asia/Brunei";
        "Asia/Chita": "Asia/Chita";
        "Asia/Colombo": "Asia/Colombo";
        "Asia/Damascus": "Asia/Damascus";
        "Asia/Dhaka": "Asia/Dhaka";
        "Asia/Dili": "Asia/Dili";
        "Asia/Dubai": "Asia/Dubai";
        "Asia/Dushanbe": "Asia/Dushanbe";
        "Asia/Famagusta": "Asia/Famagusta";
        "Asia/Gaza": "Asia/Gaza";
        "Asia/Hebron": "Asia/Hebron";
        "Asia/Ho_Chi_Minh": "Asia/Ho_Chi_Minh";
        "Asia/Hong_Kong": "Asia/Hong_Kong";
        "Asia/Hovd": "Asia/Hovd";
        "Asia/Irkutsk": "Asia/Irkutsk";
        "Asia/Jakarta": "Asia/Jakarta";
        "Asia/Jayapura": "Asia/Jayapura";
        "Asia/Jerusalem": "Asia/Jerusalem";
        "Asia/Kabul": "Asia/Kabul";
        "Asia/Kamchatka": "Asia/Kamchatka";
        "Asia/Karachi": "Asia/Karachi";
        "Asia/Kathmandu": "Asia/Kathmandu";
        "Asia/Khandyga": "Asia/Khandyga";
        "Asia/Kolkata": "Asia/Kolkata";
        "Asia/Krasnoyarsk": "Asia/Krasnoyarsk";
        "Asia/Kuala_Lumpur": "Asia/Kuala_Lumpur";
        "Asia/Kuching": "Asia/Kuching";
        "Asia/Kuwait": "Asia/Kuwait";
        "Asia/Macau": "Asia/Macau";
        "Asia/Magadan": "Asia/Magadan";
        "Asia/Makassar": "Asia/Makassar";
        "Asia/Manila": "Asia/Manila";
        "Asia/Muscat": "Asia/Muscat";
        "Asia/Nicosia": "Asia/Nicosia";
        "Asia/Novokuznetsk": "Asia/Novokuznetsk";
        "Asia/Novosibirsk": "Asia/Novosibirsk";
        "Asia/Omsk": "Asia/Omsk";
        "Asia/Oral": "Asia/Oral";
        "Asia/Phnom_Penh": "Asia/Phnom_Penh";
        "Asia/Pontianak": "Asia/Pontianak";
        "Asia/Pyongyang": "Asia/Pyongyang";
        "Asia/Qatar": "Asia/Qatar";
        "Asia/Qostanay": "Asia/Qostanay";
        "Asia/Qyzylorda": "Asia/Qyzylorda";
        "Asia/Riyadh": "Asia/Riyadh";
        "Asia/Sakhalin": "Asia/Sakhalin";
        "Asia/Samarkand": "Asia/Samarkand";
        "Asia/Seoul": "Asia/Seoul";
        "Asia/Shanghai": "Asia/Shanghai";
        "Asia/Singapore": "Asia/Singapore";
        "Asia/Srednekolymsk": "Asia/Srednekolymsk";
        "Asia/Taipei": "Asia/Taipei";
        "Asia/Tashkent": "Asia/Tashkent";
        "Asia/Tbilisi": "Asia/Tbilisi";
        "Asia/Tehran": "Asia/Tehran";
        "Asia/Thimphu": "Asia/Thimphu";
        "Asia/Tokyo": "Asia/Tokyo";
        "Asia/Tomsk": "Asia/Tomsk";
        "Asia/Ulaanbaatar": "Asia/Ulaanbaatar";
        "Asia/Urumqi": "Asia/Urumqi";
        "Asia/Ust-Nera": "Asia/Ust-Nera";
        "Asia/Vientiane": "Asia/Vientiane";
        "Asia/Vladivostok": "Asia/Vladivostok";
        "Asia/Yakutsk": "Asia/Yakutsk";
        "Asia/Yangon": "Asia/Yangon";
        "Asia/Yekaterinburg": "Asia/Yekaterinburg";
        "Asia/Yerevan": "Asia/Yerevan";
        "Atlantic/Azores": "Atlantic/Azores";
        "Atlantic/Bermuda": "Atlantic/Bermuda";
        "Atlantic/Canary": "Atlantic/Canary";
        "Atlantic/Cape_Verde": "Atlantic/Cape_Verde";
        "Atlantic/Faroe": "Atlantic/Faroe";
        "Atlantic/Madeira": "Atlantic/Madeira";
        "Atlantic/Reykjavik": "Atlantic/Reykjavik";
        "Atlantic/South_Georgia": "Atlantic/South_Georgia";
        "Atlantic/St_Helena": "Atlantic/St_Helena";
        "Atlantic/Stanley": "Atlantic/Stanley";
        "Australia/Adelaide": "Australia/Adelaide";
        "Australia/Brisbane": "Australia/Brisbane";
        "Australia/Broken_Hill": "Australia/Broken_Hill";
        "Australia/Darwin": "Australia/Darwin";
        "Australia/Eucla": "Australia/Eucla";
        "Australia/Hobart": "Australia/Hobart";
        "Australia/Lindeman": "Australia/Lindeman";
        "Australia/Lord_Howe": "Australia/Lord_Howe";
        "Australia/Melbourne": "Australia/Melbourne";
        "Australia/Perth": "Australia/Perth";
        "Australia/Sydney": "Australia/Sydney";
        "Europe/Amsterdam": "Europe/Amsterdam";
        "Europe/Andorra": "Europe/Andorra";
        "Europe/Astrakhan": "Europe/Astrakhan";
        "Europe/Athens": "Europe/Athens";
        "Europe/Belgrade": "Europe/Belgrade";
        "Europe/Berlin": "Europe/Berlin";
        "Europe/Bratislava": "Europe/Bratislava";
        "Europe/Brussels": "Europe/Brussels";
        "Europe/Bucharest": "Europe/Bucharest";
        "Europe/Budapest": "Europe/Budapest";
        "Europe/Busingen": "Europe/Busingen";
        "Europe/Chisinau": "Europe/Chisinau";
        "Europe/Copenhagen": "Europe/Copenhagen";
        "Europe/Dublin": "Europe/Dublin";
        "Europe/Gibraltar": "Europe/Gibraltar";
        "Europe/Guernsey": "Europe/Guernsey";
        "Europe/Helsinki": "Europe/Helsinki";
        "Europe/Isle_of_Man": "Europe/Isle_of_Man";
        "Europe/Istanbul": "Europe/Istanbul";
        "Europe/Jersey": "Europe/Jersey";
        "Europe/Kaliningrad": "Europe/Kaliningrad";
        "Europe/Kirov": "Europe/Kirov";
        "Europe/Kyiv": "Europe/Kyiv";
        "Europe/Lisbon": "Europe/Lisbon";
        "Europe/Ljubljana": "Europe/Ljubljana";
        "Europe/London": "Europe/London";
        "Europe/Luxembourg": "Europe/Luxembourg";
        "Europe/Madrid": "Europe/Madrid";
        "Europe/Malta": "Europe/Malta";
        "Europe/Mariehamn": "Europe/Mariehamn";
        "Europe/Minsk": "Europe/Minsk";
        "Europe/Monaco": "Europe/Monaco";
        "Europe/Moscow": "Europe/Moscow";
        "Europe/Oslo": "Europe/Oslo";
        "Europe/Paris": "Europe/Paris";
        "Europe/Podgorica": "Europe/Podgorica";
        "Europe/Prague": "Europe/Prague";
        "Europe/Riga": "Europe/Riga";
        "Europe/Rome": "Europe/Rome";
        "Europe/Samara": "Europe/Samara";
        "Europe/San_Marino": "Europe/San_Marino";
        "Europe/Sarajevo": "Europe/Sarajevo";
        "Europe/Saratov": "Europe/Saratov";
        "Europe/Simferopol": "Europe/Simferopol";
        "Europe/Skopje": "Europe/Skopje";
        "Europe/Sofia": "Europe/Sofia";
        "Europe/Stockholm": "Europe/Stockholm";
        "Europe/Tallinn": "Europe/Tallinn";
        "Europe/Tirane": "Europe/Tirane";
        "Europe/Ulyanovsk": "Europe/Ulyanovsk";
        "Europe/Vaduz": "Europe/Vaduz";
        "Europe/Vatican": "Europe/Vatican";
        "Europe/Vienna": "Europe/Vienna";
        "Europe/Vilnius": "Europe/Vilnius";
        "Europe/Volgograd": "Europe/Volgograd";
        "Europe/Warsaw": "Europe/Warsaw";
        "Europe/Zagreb": "Europe/Zagreb";
        "Europe/Zurich": "Europe/Zurich";
        "Indian/Antananarivo": "Indian/Antananarivo";
        "Indian/Chagos": "Indian/Chagos";
        "Indian/Christmas": "Indian/Christmas";
        "Indian/Cocos": "Indian/Cocos";
        "Indian/Comoro": "Indian/Comoro";
        "Indian/Kerguelen": "Indian/Kerguelen";
        "Indian/Mahe": "Indian/Mahe";
        "Indian/Maldives": "Indian/Maldives";
        "Indian/Mauritius": "Indian/Mauritius";
        "Indian/Mayotte": "Indian/Mayotte";
        "Indian/Reunion": "Indian/Reunion";
        "Pacific/Apia": "Pacific/Apia";
        "Pacific/Auckland": "Pacific/Auckland";
        "Pacific/Bougainville": "Pacific/Bougainville";
        "Pacific/Chatham": "Pacific/Chatham";
        "Pacific/Chuuk": "Pacific/Chuuk";
        "Pacific/Easter": "Pacific/Easter";
        "Pacific/Efate": "Pacific/Efate";
        "Pacific/Fakaofo": "Pacific/Fakaofo";
        "Pacific/Fiji": "Pacific/Fiji";
        "Pacific/Funafuti": "Pacific/Funafuti";
        "Pacific/Galapagos": "Pacific/Galapagos";
        "Pacific/Gambier": "Pacific/Gambier";
        "Pacific/Guadalcanal": "Pacific/Guadalcanal";
        "Pacific/Guam": "Pacific/Guam";
        "Pacific/Honolulu": "Pacific/Honolulu";
        "Pacific/Kanton": "Pacific/Kanton";
        "Pacific/Kiritimati": "Pacific/Kiritimati";
        "Pacific/Kosrae": "Pacific/Kosrae";
        "Pacific/Kwajalein": "Pacific/Kwajalein";
        "Pacific/Majuro": "Pacific/Majuro";
        "Pacific/Marquesas": "Pacific/Marquesas";
        "Pacific/Midway": "Pacific/Midway";
        "Pacific/Nauru": "Pacific/Nauru";
        "Pacific/Niue": "Pacific/Niue";
        "Pacific/Norfolk": "Pacific/Norfolk";
        "Pacific/Noumea": "Pacific/Noumea";
        "Pacific/Pago_Pago": "Pacific/Pago_Pago";
        "Pacific/Palau": "Pacific/Palau";
        "Pacific/Pitcairn": "Pacific/Pitcairn";
        "Pacific/Pohnpei": "Pacific/Pohnpei";
        "Pacific/Port_Moresby": "Pacific/Port_Moresby";
        "Pacific/Rarotonga": "Pacific/Rarotonga";
        "Pacific/Saipan": "Pacific/Saipan";
        "Pacific/Tahiti": "Pacific/Tahiti";
        "Pacific/Tarawa": "Pacific/Tarawa";
        "Pacific/Tongatapu": "Pacific/Tongatapu";
        "Pacific/Wake": "Pacific/Wake";
        "Pacific/Wallis": "Pacific/Wallis";
        UTC: "UTC";
    }>;
}, z.core.$strip>;

type Location = {
    id: number;
    short: string;
    long: string;
    created_at: string;
    updated_at: string | null;
};

type Node$1 = {
    id: number;
    uuid: string;
    public: boolean;
    name: string;
    description: Nullable<string>;
    fqdn: string;
    scheme: "https" | "http";
    behind_proxy: boolean;
    maintenance_mode: boolean;
    memory: number;
    memory_overallocate: number;
    disk: number;
    disk_overallocate: number;
    cpu: number;
    cpu_overallocate: number;
    upload_size: number;
    daemon_listen: number;
    daemon_sftp: number;
    daemon_sftp_alias: Nullable<string>;
    daemon_base: string;
    daemon_connect: number;
    created_at: string;
    updated_at: Nullable<string>;
    tags: string[];
    allocated_resources: {
        memory: number;
        disk: number;
        cpu: number;
    };
    relationships?: {
        allocations?: GenericListResponse<GenericResponse<Allocation, "allocation">>;
        location?: GenericResponse<Location, "location">;
        servers?: GenericListResponse<GenericResponse<ApplicationServer, "server">>;
    };
};
type NodeConfiguration = {
    debug: boolean;
    uuid: string;
    token_id: string;
    token: string;
    api: {
        host: string;
        port: number;
        upload_limit: number;
        ssl: {
            enabled: boolean;
            cert: string;
            key: string;
        };
    };
    system: {
        data: string;
        sftp: {
            bind_port: number;
        };
    };
    allowed_mounts: string[];
    remote: string;
};

type Allocation = {
    id: number;
    ip: string;
    alias: Nullable<string>;
    port: number;
    notes: Nullable<string>;
    assigned: boolean;
};
type AllocationRel = Allocation & {
    relationships?: {
        node?: GenericResponse<Node$1, "node">;
        server?: GenericResponse<ApplicationServer, "server">;
    };
};

declare class NodesAllocations {
    private readonly r;
    private readonly id;
    constructor(requester: AxiosInstance, id: number);
    list: (include?: ("node" | "server")[]) => Promise<AllocationRel[]>;
    create: (ip: string, ports: string[], alias?: string) => Promise<void>;
    delete: (alloc_id: number) => Promise<void>;
}

declare class Nodes {
    private readonly r;
    constructor(requester: AxiosInstance);
    list: (include?: ("allocations" | "location" | "servers")[], page?: number) => Promise<Node$1[]>;
    listDeployable: (filters: {
        disk: number;
        memory: number;
        cpu?: number;
        location_ids?: string[];
        tags?: string[];
    }, include?: ("allocations" | "location" | "servers")[], page?: number) => Promise<Node$1[]>;
    info: (id: number, include?: ("allocations" | "location" | "servers")[]) => Promise<Node$1>;
    create: (node: z.infer<typeof NodeCreateSchema>) => Promise<Node$1>;
    get_configuration: (id: number) => Promise<NodeConfiguration>;
    update: (id: number, node: z.infer<typeof NodeCreateSchema>) => Promise<Node$1>;
    delete: (id: number) => Promise<void>;
    allocations: (server_id: number) => NodesAllocations;
}
declare const NodeCreateSchema: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    public: z.ZodOptional<z.ZodBoolean>;
    fqdn: z.ZodString;
    scheme: z.ZodEnum<{
        https: "https";
        http: "http";
    }>;
    behind_proxy: z.ZodOptional<z.ZodBoolean>;
    memory: z.ZodNumber;
    memory_overallocate: z.ZodNumber;
    disk: z.ZodNumber;
    disk_overallocate: z.ZodNumber;
    cpu: z.ZodNumber;
    cpu_overallocate: z.ZodNumber;
    daemon_base: z.ZodOptional<z.ZodString>;
    daemon_sftp: z.ZodNumber;
    daemon_sftp_alias: z.ZodOptional<z.ZodString>;
    daemon_listen: z.ZodNumber;
    daemon_connect: z.ZodNumber;
    maintenance_mode: z.ZodOptional<z.ZodBoolean>;
    upload_size: z.ZodNumber;
    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;

declare class ServersDatabases {
    private readonly r;
    private readonly id;
    constructor(r: AxiosInstance, server_id: number);
    list: () => Promise<ServerDatabase[]>;
    create: (database: string, remote: string, host: string) => Promise<ServerDatabase>;
    info: (database_id: number) => Promise<ServerDatabase>;
    delete: (database_id: number) => Promise<void>;
    resetPassword: (database_id: number) => Promise<void>;
}

declare class Servers {
    private readonly r;
    private readonly id;
    databases: ServersDatabases;
    constructor(r: AxiosInstance, server_id: number);
    info: (include?: ("egg" | "subusers")[]) => Promise<ApplicationServer>;
    delete: (force?: boolean) => Promise<void>;
    updateDetails: (opts: z.infer<typeof UpdateDetailsSchema>) => Promise<void>;
    updateBuild: (opts: z.infer<typeof UpdateBuildSchema>) => Promise<void>;
    updateStartup: (opts: z.infer<typeof UpdateStartupSchema>) => Promise<void>;
    suspend: () => Promise<void>;
    unsuspend: () => Promise<void>;
    reinstall: () => Promise<void>;
    transferStart: (node_id: number, allocation_id: number, allocation_additional?: number[]) => Promise<void>;
    transferCancel: () => Promise<void>;
}
declare const CreateServerSchema: z.ZodObject<{
    external_id: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
    description: z.ZodOptional<z.ZodString>;
    user: z.ZodNumber;
    egg: z.ZodNumber;
    docker_image: z.ZodOptional<z.ZodString>;
    startup: z.ZodOptional<z.ZodString>;
    environment: z.ZodRecord<z.ZodString, z.ZodString>;
    skip_scripts: z.ZodOptional<z.ZodBoolean>;
    oom_killer: z.ZodOptional<z.ZodBoolean>;
    start_on_completion: z.ZodOptional<z.ZodBoolean>;
    docker_labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    limits: z.ZodObject<{
        memory: z.ZodNumber;
        swap: z.ZodNumber;
        disk: z.ZodNumber;
        io: z.ZodNumber;
        threads: z.ZodOptional<z.ZodString>;
        cpu: z.ZodNumber;
    }, z.core.$strip>;
    feature_limits: z.ZodObject<{
        databases: z.ZodNumber;
        allocations: z.ZodNumber;
        backups: z.ZodNumber;
    }, z.core.$strip>;
    allocation: z.ZodOptional<z.ZodObject<{
        default: z.ZodString;
        additional: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
    deploy: z.ZodOptional<z.ZodObject<{
        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
        dedicated_ip: z.ZodOptional<z.ZodBoolean>;
        port_range: z.ZodOptional<z.ZodArray<z.ZodString>>;
    }, z.core.$strip>>;
}, z.core.$strip>;
declare const UpdateDetailsSchema: z.ZodObject<{
    user: z.ZodNumber;
    description: z.ZodOptional<z.ZodString>;
    name: z.ZodString;
    external_id: z.ZodOptional<z.ZodString>;
    docker_labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, z.core.$strip>;
declare const UpdateBuildSchema: z.ZodObject<{
    oom_killer: z.ZodOptional<z.ZodBoolean>;
    limits: z.ZodObject<{
        memory: z.ZodNumber;
        swap: z.ZodNumber;
        disk: z.ZodNumber;
        io: z.ZodNumber;
        threads