@vates/types 1.15.0 → 1.17.0

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 export * from './common.mjs';
 export * from './xen-api.mjs';
 export * from './xo.mjs';
+export * from './xo-app.mjs';
 export * from './lib/xen-orchestra-xapi.mjs';
 export * from './lib/complex-matcher.mjs';

package/dist/index.mjs

@@ -1,5 +1,6 @@
 export * from './common.mjs';
 export * from './xen-api.mjs';
 export * from './xo.mjs';
+export * from './xo-app.mjs';
 export * from './lib/xen-orchestra-xapi.mjs';
 export * from './lib/complex-matcher.mjs';

package/dist/lib/xen-orchestra-xapi.d.mts

@@ -1,4 +1,5 @@
-import { WrappedXenApiRecord, XenApiHost, XenApiNetworkWrapped, XenApiRecord, XenApiSr, XenApiTask, XenApiVdi, XenApiVm, XenApiVmWrapped } from '../xen-api.mjs';
+import { WrappedXenApiRecord, XenApiHost, XenApiNetworkWrapped, XenApiRecord, XenApiSr, XenApiTask, XenApiVbd, XenApiVdi, XenApiVm, XenApiVmWrapped, XenApiVtpm } from '../xen-api.mjs';
+import type { OPAQUE_REF_NULL, VBD_MODE, VBD_TYPE } from '../common.mjs';
 import type { PassThrough, Readable } from 'node:stream';
 import type { XoGpuGroup, XoVgpuType, XoHost, XoNetwork, XoPif, XoSr, XoUser, XoVdi, XoVm, XoVmTemplate } from '../xo.mjs';
 import type { SUPPORTED_VDI_FORMAT } from '../common.mjs';
@@ -126,9 +127,24 @@ export interface Xapi {
         gpuGroup?: XoGpuGroup['id'];
         copyHostBiosStrings?: boolean;
         hvmBootFirmware?: 'uefi' | 'bios';
+        secureBoot?: boolean;
     }, checkLimits?: boolean, creatorId?: XoUser['id'], opts?: {
         destroyAllVifs: boolean;
     }): Promise<XenApiVmWrapped>;
+    VBD_create(params: {
+        bootable?: boolean;
+        empty?: boolean;
+        mode?: VBD_MODE;
+        other_config?: Record<string, string>;
+        qos_algorithm_params?: Record<string, string>;
+        qos_algorithm_type?: string;
+        type?: VBD_TYPE;
+        unpluggable?: boolean;
+        userdevice?: string;
+        VDI: XenApiVdi['$ref'] | OPAQUE_REF_NULL;
+        VM: XenApiVm['$ref'];
+    }): Promise<XenApiVbd['$ref']>;
+    VBD_destroy(vbdRef: XenApiVbd['$ref']): Promise<void>;
     VDI_destroy(vdiRef: XenApiVdi['$ref']): Promise<void>;
     VDI_destroyCloudInitConfig(vdiRef: XenApiVdi['$ref'], opts?: {
         timeLimit?: number;
@@ -161,4 +177,9 @@ export interface Xapi {
         body: Readable;
     }>;
     isHyperThreadingEnabled(hostId: XoHost['id']): Promise<boolean | null>;
+    VTPM_create(params: {
+        VM: XenApiVm['$ref'];
+        is_unique?: boolean;
+        contents?: string;
+    }): Promise<XenApiVtpm['$ref']>;
 }

package/dist/xen-api.d.mts

@@ -894,6 +894,7 @@ export interface XenApiMessage {
     timestamp: string;
     uuid: string;
 }
+export type XenApiMessageWrapped = WrapperXenApi<XenApiMessage, 'message'>;
 export interface XenApiSecret {
     $ref: Branded<'secret'>;
     other_config: Record<string, string>;

package/dist/xo-app.d.mts

@@ -0,0 +1,230 @@
+import { EventEmitter } from 'node:stream';
+import type { AnyXoBackupJob, AnyXoJob, AnyXoLog, XapiXoRecord, XoAuthenticationToken, XoBackupRepository, XoConfigBackupArchive, XoGroup, XoHost, XoPool, XoPoolBackupArchive, XoProxy, XoSchedule, XoServer, XoTask, XoUser, XoVm, XoVmBackupArchive } from './xo.mjs';
+import { VatesTask } from './lib/vates-task.mjs';
+import { Xapi, XapiHostStats, XapiPoolStats, XapiStatsGranularity, XapiVmStats, XenApiGpuGroupWrapped, XenApiHostWrapped, XenApiMessageWrapped, XenApiNetworkWrapped, XenApiPbdWrapped, XenApiPciWrapped, XenApiPgpuWrapped, XenApiPifWrapped, XenApiPoolWrapped, XenApiSmWrapped, XenApiSrWrapped, XenApiVbdWrapped, XenApiVdiWrapped, XenApiVgpuTypeWrapped, XenApiVgpuWrapped, XenApiVifWrapped, XenApiVmWrapped, XenApiVtpmWrapped } from './index.mjs';
+export type XapiConnection = Xapi & {
+    status: string;
+    pool?: {
+        uuid: string;
+    };
+    sessionId: string;
+    _url?: {
+        protocol: string;
+        hostname: string;
+        port?: string;
+    };
+};
+type XapiRecordByXapiXoRecord = {
+    gpuGroup: XenApiGpuGroupWrapped;
+    host: XenApiHostWrapped;
+    message: XenApiMessageWrapped;
+    network: XenApiNetworkWrapped;
+    PBD: XenApiPbdWrapped;
+    PCI: XenApiPciWrapped;
+    PGPU: XenApiPgpuWrapped;
+    PIF: XenApiPifWrapped;
+    pool: XenApiPoolWrapped;
+    SR: XenApiSrWrapped;
+    SM: XenApiSmWrapped;
+    VBD: XenApiVbdWrapped;
+    VDI: XenApiVdiWrapped;
+    'VDI-snapshot': XenApiVdiWrapped;
+    'VDI-unmanaged': XenApiVdiWrapped;
+    vgpu: XenApiVgpuWrapped;
+    vgpuType: XenApiVgpuTypeWrapped;
+    VIF: XenApiVifWrapped;
+    VM: XenApiVmWrapped;
+    'VM-controller': XenApiVmWrapped;
+    'VM-snapshot': XenApiVmWrapped;
+    'VM-template': XenApiVmWrapped;
+    VTPM: XenApiVtpmWrapped;
+};
+export type XoApp = {
+    config: {
+        getOptional(path: string): Record<string, string> | undefined;
+        getOptionalDuration(path: string): number | undefined;
+        getGuiRoutes(): Promise<{
+            default: {
+                url: string;
+                path: string;
+            };
+            v5?: {
+                url: string;
+                path: string;
+            };
+            v6?: {
+                url: string;
+                path: string;
+            };
+            [key: string]: undefined | {
+                url: string;
+                path: string;
+            };
+        }>;
+    };
+    objects: EventEmitter & {
+        allIndexes: {
+            type: {
+                getEventEmitterByType(type: XapiXoRecord['type']): EventEmitter;
+            };
+        };
+    };
+    tasks: EventEmitter & {
+        abort(id: XoTask['id'], reason?: string): Promise<void>;
+        clearLogs(): Promise<void>;
+        create: (params: {
+            name: string;
+            objectId?: string;
+            type?: string;
+        }) => VatesTask;
+        deleteLog(id: XoTask['id']): Promise<void>;
+        get(id: XoTask['id']): Promise<XoTask>;
+        list(opts?: {
+            filter?: string | ((obj: XoTask) => boolean);
+            limit?: number;
+        }): AsyncGenerator<XoTask>;
+        watch(id: XoTask['id'], cb: (task: XoTask) => void): Promise<() => void>;
+    };
+    apiContext: {
+        user?: XoUser;
+        permission?: XoUser['permission'] | 'none' | null;
+    };
+    addUserToGroup: (userId: XoUser['id'], groupId: XoGroup['id']) => Promise<void>;
+    authenticateUser: (credentials: {
+        token?: string;
+        username?: string;
+        password?: string;
+    }, userData?: {
+        ip?: string;
+    }, opts?: {
+        bypassOtp?: boolean;
+    }) => Promise<{
+        bypassOtp: boolean;
+        expiration: number;
+        user: XoUser;
+    }>;
+    checkFeatureAuthorization(featureCode: string): Promise<void>;
+    connectXenServer(id: XoServer['id']): Promise<void>;
+    createAuthenticationToken(opts: {
+        client?: {
+            id?: string;
+            [key: string]: unknown;
+        };
+        description?: string;
+        expiresIn?: string | number;
+        userId: XoUser['id'];
+    }): Promise<XoAuthenticationToken>;
+    createUser(params: {
+        name?: string;
+        password?: string;
+        [key: string]: unknown;
+    }): Promise<XoUser>;
+    deleteGroup(id: XoGroup['id']): Promise<void>;
+    deleteUser(id: XoUser['id']): Promise<void>;
+    createGroup(params: {
+        name: string;
+        provider?: string;
+        providerGroup?: string;
+    }): Promise<XoGroup>;
+    disconnectXenServer(id: XoServer['id']): Promise<void>;
+    getAllGroups(): Promise<XoGroup[]>;
+    getAllProxies(): Promise<XoProxy[]>;
+    getAllJobs<T extends AnyXoBackupJob['type']>(type: T): Promise<Extract<AnyXoBackupJob, {
+        type: T;
+    }>[]>;
+    getAllJobs(type?: string): Promise<AnyXoJob[]>;
+    getProxy(id: XoProxy['id']): Promise<XoProxy>;
+    getRemote(id: XoBackupRepository['id']): Promise<XoBackupRepository>;
+    getAllRemotes(): Promise<XoBackupRepository[]>;
+    getAllRemotesInfo(): Promise<Record<XoBackupRepository['id'], {
+        size?: number;
+        used?: number;
+        available?: number;
+        encryption?: {
+            algorithm: string;
+            isLegacy: boolean;
+            recommanded: string;
+        };
+    }>>;
+    getAllSchedules(): Promise<XoSchedule[]>;
+    getAllUsers(): Promise<XoUser[]>;
+    getAllXenServers(): Promise<XoServer[]>;
+    getAuthenticationTokensForUser(userId: XoUser['id']): Promise<XoAuthenticationToken[]>;
+    getBackupNgLogs(): Promise<Record<string, AnyXoLog>>;
+    getBackupNgLogs(id: AnyXoLog['id']): Promise<AnyXoLog>;
+    getBackupNgLogsSorted(opts: {
+        after?: number;
+        before?: number;
+        filter: (log: AnyXoLog) => boolean;
+        limit?: number;
+    }): Promise<AnyXoLog[]>;
+    getGroup(id: XoGroup['id']): Promise<XoGroup>;
+    getHVSupportedVersions: undefined | (() => Promise<{
+        [key: XoHost['productBrand']]: string;
+    }>);
+    getJob<T extends AnyXoJob>(id: T['id']): Promise<T>;
+    getObject: <T extends XapiXoRecord>(id: T['id'], type?: T['type'] | T['type'][]) => T;
+    getObjectsByType: <T extends XapiXoRecord>(type: T['type'], opts?: {
+        filter?: string | ((obj: T) => boolean);
+        limit?: number;
+    }) => Record<T['id'], T> | undefined;
+    getTotalBackupSizeOnRemote(id: XoBackupRepository['id']): Promise<{
+        onDisk: number;
+    }>;
+    getSchedule(id: XoSchedule['id']): Promise<XoSchedule>;
+    getUser: (id: XoUser['id']) => Promise<XoUser>;
+    getXapi(maybeId: XapiXoRecord['id'] | XapiXoRecord): Xapi;
+    getXapiHostStats: (hostId: XoHost['id'], granularity?: XapiStatsGranularity) => Promise<XapiHostStats>;
+    getXapiObject: <T extends XapiXoRecord>(maybeId: T['id'] | T, type: T['type'] | T['type'][]) => XapiRecordByXapiXoRecord[T['type']];
+    getXapiPoolStats(poolId: XoPool['id'], granularity?: XapiStatsGranularity): Promise<XapiPoolStats>;
+    getXapiVmStats: (vmId: XoVm['id'], granularity?: XapiStatsGranularity) => Promise<XapiVmStats>;
+    getXenServer(id: XoServer['id']): Promise<XoServer>;
+    hasFeatureAuthorization(featureCode: string): Promise<boolean>;
+    hasObject<T extends XapiXoRecord>(id: T['id'], type: T['type']): boolean;
+    listMetadataBackups(backupRepositoryIds: XoBackupRepository['id'][]): Promise<{
+        xo: Record<XoBackupRepository['id'], XoConfigBackupArchive[]>;
+        pool: Record<XoBackupRepository['id'], Record<XoPool['id'], XoPoolBackupArchive[]>>;
+    }>;
+    listVmBackupsNg(backupRepositoryIds: XoBackupRepository['id'][], opts?: {
+        _forceRefresh?: boolean;
+        vmId: XoVm['id'];
+    }): Promise<Record<XoBackupRepository['id'], Record<XoVm['id'], XoVmBackupArchive[]>>>;
+    /** Allow to add a new server in the DB (XCP-ng/XenServer) */
+    registerXenServer(body: Pick<XoServer, 'host' | 'httpProxy' | 'label' | 'username'> & {
+        allowUnauthorized?: XoServer['allowUnauthorized'];
+        password: string;
+        readOnly?: XoServer['readOnly'];
+    }): Promise<XoServer>;
+    rollingPoolReboot(pool: XoPool, opts?: {
+        parentTask?: VatesTask;
+    }): Promise<void>;
+    rollingPoolUpdate(pool: XoPool, opts?: {
+        rebootVm?: boolean;
+        parentTask?: VatesTask;
+    }): Promise<void>;
+    removeUserFromGroup(userId: XoUser['id'], id: XoGroup['id']): Promise<void>;
+    runJob(job: AnyXoJob, schedule: XoSchedule): void;
+    runWithApiContext: (user: XoUser | undefined, fn: () => void) => Promise<unknown>;
+    /** Remove a server from the DB (XCP-ng/XenServer) */
+    unregisterXenServer(id: XoServer['id']): Promise<void>;
+    updateUser(id: XoUser['id'], updates: {
+        /**
+         * @deprecated
+         */
+        email?: string;
+        authProviders?: Record<string, string>;
+        name?: string;
+        password?: string;
+        permission?: string;
+        preferences?: Record<string, string>;
+    }): Promise<void>;
+    updateGroup(id: XoGroup['id'], updates: {
+        name?: string;
+    }): void;
+    getAllXapis(): Record<string, XapiConnection>;
+    getObjects(opts?: {
+        filter?: Record<string, unknown>;
+        limit?: number;
+    }): Record<string, XapiXoRecord>;
+};
+export {};

package/dist/xo-app.mjs

@@ -0,0 +1 @@
+export {};

package/dist/xo.d.mts

@@ -406,7 +406,6 @@ export type XoPool = BaseXapiXo & {
     tags: string[];
     type: 'pool';
     vtpmSupported: boolean;
-    xosanPackInstallationTime: number | null;
     zstdSupported: boolean;
 };
 export type XoProxy = {
@@ -604,11 +603,13 @@ export type XoTask = {
         data: unknown;
         message: string;
     }[];
+    progress?: number;
     properties: {
         method?: string;
         name?: string;
         objectId?: string;
         params?: Record<string, unknown>;
+        progress?: number;
         type?: string;
         userId?: string;
         [key: string]: unknown | undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vates/types",
   "private": false,
-  "version": "1.15.0",
+  "version": "1.17.0",
   "main": "./dist/index.mjs",
   "exports": {
     ".": {
@@ -9,6 +9,7 @@
       "types": "./dist/index.d.mts"
     },
     "./xo": "./dist/xo.d.mts",
+    "./xo-app": "./dist/xo-app.d.mts",
     "./xen-api": "./dist/xen-api.d.mts",
     "./common": {
       "default": "./dist/common.mjs",