@vates/types 1.0.1 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (7) hide show
  1. package/dist/common.d.mts +56 -0
  2. package/dist/common.mjs +6 -0
  3. package/dist/lib/vates-task.d.mts +5 -0
  4. package/dist/lib/vates-task.mjs +1 -0
  5. package/dist/xen-api.d.mts +314 -344
  6. package/dist/xo.d.mts +187 -20
  7. package/package.json +5 -1
package/dist/xen-api.d.mts CHANGED
@@ -1,31 +1,43 @@
1
- import type { AFTER_APPLY_GUIDANCE, ALLOCATION_ALGORITHM, BOND_MODE, Branded, CERTIFICATE_TYPE, CLS, CLUSTER_HOST_OPERATION, CLUSTER_OPERATION, CONSOLE_PROTOCOL, DOMAIN_TYPE, EVENT_OPERATION, HOST_ALLOWED_OPERATIONS, HOST_DISPLAY, HOST_NUMA_AFFINITY_POLICY, IP_CONFIGURATION_MODE, IPV6_CONFIGURATION_MODE, LATEST_SYNCED_UPDATES_APPLIED_STATE, NETWORK_DEFAULT_LOCKING_MODE, NETWORK_OPERATIONS, NETWORK_PURPOSE, ON_BOOT, ON_CRASH_BEHAVIOUR, ON_NORMAL_EXIT, ON_SOFTREBOOT_BEHAVIOR, PERSISTENCE_BACKEND, PGPU_DOM0_ACCESS, PIF_IGMP_STATUS, POOL_ALLOWED_OPERATIONS, PRIMARY_ADDRESS_TYPE, PVS_PROXY_STATUS, SDN_CONTROLLER_PROTOCOL, SR_HEALTH, SRIOV_CONFIGURATION_MODE, STORAGE_OPERATIONS, TASK_ALLOWED_OPERATIONS, TASK_STATUS_TYPE, TELEMETRY_FREQUENCY, TRISTATE_TYPE, TUNNEL_PROTOCOL, UPDATE_AFTER_APPLY_GUIDANCE, UPDATE_GUIDANCES, UPDATE_SYNC_FREQUENCY, VBD_MODE, VBD_OPERATIONS, VBD_TYPE, VDI_OPERATIONS, VDI_TYPE, VGPU_TYPE_IMPLEMENTATION, VIF_IPV4_CONFIGURATION_MODE, VIF_IPV6_CONFIGURATION_MODE, VIF_LOCKING_MODE, VIF_OPERATIONS, VM_APPLIANCE_OPERATION, VM_OPERATIONS, VM_POWER_STATE, VMPP_ARCHIVE_FREQUENCY, VMPP_ARCHIVE_TARGET_TYPE, VMPP_BACKUP_FREQUENCY, VMPP_BACKUP_TYPE, VMSS_FREQUENCY, VMSS_TYPE, VTPM_OPERATIONS, VUSB_OPERATIONS } from './common.mjs';
1
+ import type { AFTER_APPLY_GUIDANCE, ALLOCATION_ALGORITHM, BOND_MODE, Branded, CERTIFICATE_TYPE, CLS, CLUSTER_HOST_OPERATION, CLUSTER_OPERATION, CONSOLE_PROTOCOL, DOMAIN_TYPE, EVENT_OPERATION, HOST_ALLOWED_OPERATIONS, HOST_DISPLAY, HOST_NUMA_AFFINITY_POLICY, IP_CONFIGURATION_MODE, IPV6_CONFIGURATION_MODE, LATEST_SYNCED_UPDATES_APPLIED_STATE, NETWORK_DEFAULT_LOCKING_MODE, NETWORK_OPERATIONS, NETWORK_PURPOSE, ON_BOOT, ON_CRASH_BEHAVIOUR, ON_NORMAL_EXIT, ON_SOFTREBOOT_BEHAVIOR, OPAQUE_REF_NULL, PERSISTENCE_BACKEND, PGPU_DOM0_ACCESS, PIF_IGMP_STATUS, POOL_ALLOWED_OPERATIONS, PRIMARY_ADDRESS_TYPE, PVS_PROXY_STATUS, SDN_CONTROLLER_PROTOCOL, SR_HEALTH, SRIOV_CONFIGURATION_MODE, STORAGE_OPERATIONS, TASK_ALLOWED_OPERATIONS, TASK_STATUS_TYPE, TELEMETRY_FREQUENCY, TRISTATE_TYPE, TUNNEL_PROTOCOL, UPDATE_AFTER_APPLY_GUIDANCE, UPDATE_GUIDANCES, UPDATE_SYNC_FREQUENCY, VBD_MODE, VBD_OPERATIONS, VBD_TYPE, VDI_OPERATIONS, VDI_TYPE, VGPU_TYPE_IMPLEMENTATION, VIF_IPV4_CONFIGURATION_MODE, VIF_IPV6_CONFIGURATION_MODE, VIF_LOCKING_MODE, VIF_OPERATIONS, VM_APPLIANCE_OPERATION, VM_OPERATIONS, VM_POWER_STATE, VMPP_ARCHIVE_FREQUENCY, VMPP_ARCHIVE_TARGET_TYPE, VMPP_BACKUP_FREQUENCY, VMPP_BACKUP_TYPE, VMSS_FREQUENCY, VMSS_TYPE, VTPM_OPERATIONS, VUSB_OPERATIONS } from './common.mjs';
2
+ /**
3
+ * Add properties injected by `xen-api`.
4
+ * $ref property is also injected by XOLite, so she is not present here.
5
+ */
6
+ type WrapperXenApi<T, Type extends string, Fn = {
7
+ (): void;
8
+ }> = T & {
9
+ $call: Fn;
10
+ $callAsync: Fn;
11
+ $type: Type;
12
+ $xapi: {
13
+ call: <ReturnType>(...args: unknown[]) => Promise<ReturnType>;
14
+ callAsync: <ReturnType>(...args: unknown[]) => Promise<ReturnType>;
15
+ };
16
+ };
2
17
  export interface XenApiSession {
3
18
  $ref: Branded<'session'>;
4
- $type: 'session';
5
19
  auth_user_name: string;
6
20
  auth_user_sid: string;
7
21
  client_certificate?: boolean;
8
22
  is_local_superuser: boolean;
9
- last_active?: string;
23
+ last_active: string;
10
24
  originator: string;
11
25
  other_config: Record<string, string>;
12
- parent?: XenApiSession['$ref'];
13
- pool?: boolean;
26
+ parent: XenApiSession['$ref'] | OPAQUE_REF_NULL;
27
+ pool: boolean;
14
28
  rbac_permissions: string[];
15
- subject?: XenApiSubject['$ref'];
29
+ subject: XenApiSubject['$ref'] | OPAQUE_REF_NULL;
16
30
  tasks: XenApiTask['$ref'][];
17
- this_host?: XenApiHost['$ref'];
18
- this_user?: XenApiUser['$ref'];
31
+ this_host: XenApiHost['$ref'];
32
+ this_user: XenApiUser['$ref'];
19
33
  uuid: string;
20
34
  validation_time: string;
21
35
  }
22
36
  export interface XenApiAuth {
23
37
  $ref: Branded<'auth'>;
24
- $type: 'auth';
25
38
  }
26
39
  export interface XenApiSubject {
27
40
  $ref: Branded<'subject'>;
28
- $type: 'subject';
29
41
  other_config: Record<string, string>;
30
42
  roles: XenApiRole['$ref'][];
31
43
  subject_identifier: string;
@@ -33,7 +45,6 @@ export interface XenApiSubject {
33
45
  }
34
46
  export interface XenApiRole {
35
47
  $ref: Branded<'role'>;
36
- $type: 'role';
37
48
  is_internal?: boolean;
38
49
  name_description: string;
39
50
  name_label: string;
@@ -42,51 +53,48 @@ export interface XenApiRole {
42
53
  }
43
54
  export interface XenApiTask {
44
55
  $ref: Branded<'task'>;
45
- $type: 'task';
46
56
  allowed_operations: TASK_ALLOWED_OPERATIONS[];
47
57
  backtrace: string;
48
- created?: string;
58
+ created: string;
49
59
  current_operations: Record<string, TASK_ALLOWED_OPERATIONS>;
50
60
  error_info: string[];
51
- finished?: string;
61
+ finished: string;
52
62
  name_description: string;
53
63
  name_label: string;
54
64
  other_config: Record<string, string>;
55
- progress?: number;
56
- resident_on?: XenApiHost['$ref'];
57
- result?: string;
58
- status?: TASK_STATUS_TYPE;
59
- subtask_of?: XenApiTask['$ref'];
65
+ progress: number;
66
+ resident_on: XenApiHost['$ref'];
67
+ result: string;
68
+ status: TASK_STATUS_TYPE;
69
+ subtask_of: XenApiTask['$ref'] | OPAQUE_REF_NULL;
60
70
  subtasks: XenApiTask['$ref'][];
61
- type?: string;
71
+ type: string;
62
72
  uuid: string;
63
73
  }
64
74
  export interface XenApiEvent {
65
75
  $ref: Branded<'event'>;
66
- $type: 'event';
67
- class?: string;
68
- id?: number;
76
+ class: string;
77
+ id: number;
69
78
  /** @deprecated */
70
79
  obj_uuid?: string;
71
- operation?: EVENT_OPERATION;
72
- ref?: string;
73
- snapshot?: object;
80
+ operation: EVENT_OPERATION;
81
+ ref: string;
82
+ snapshot: object;
74
83
  /** @deprecated */
75
84
  timestamp?: string;
76
85
  }
77
86
  export interface XenApiPool {
78
87
  $ref: Branded<'pool'>;
79
- $type: 'pool';
80
88
  allowed_operations: POOL_ALLOWED_OPERATIONS[];
81
89
  blobs: Record<string, XenApiBlob['$ref']>;
82
90
  client_certificate_auth_enabled?: boolean;
83
91
  client_certificate_auth_name?: string;
84
92
  coordinator_bias: boolean;
85
93
  cpu_info: Record<string, string>;
86
- crash_dump_SR?: XenApiSr['$ref'];
94
+ crash_dump_SR: XenApiSr['$ref'] | OPAQUE_REF_NULL;
87
95
  current_operations: Record<string, POOL_ALLOWED_OPERATIONS>;
88
96
  custom_uefi_certificates?: string;
89
- default_SR?: XenApiSr['$ref'];
97
+ default_SR: XenApiSr['$ref'] | OPAQUE_REF_NULL;
90
98
  ext_auth_max_threads?: number;
91
99
  guest_agent_config: Record<string, string>;
92
100
  gui_config: Record<string, string>;
@@ -104,25 +112,25 @@ export interface XenApiPool {
104
112
  last_update_sync?: string;
105
113
  live_patching_disabled?: boolean;
106
114
  local_auth_max_threads?: number;
107
- master?: XenApiHost['$ref'];
115
+ master: XenApiHost['$ref'];
108
116
  metadata_VDIs: XenApiVdi['$ref'][];
109
117
  migration_compression?: boolean;
110
- name_description?: string;
111
- name_label?: string;
112
- other_config?: Record<string, string>;
118
+ name_description: string;
119
+ name_label: string;
120
+ other_config: Record<string, string>;
113
121
  policy_no_vendor_device: boolean;
114
122
  redo_log_enabled: boolean;
115
- redo_log_vdi?: XenApiVdi['$ref'];
123
+ redo_log_vdi: XenApiVdi['$ref'] | OPAQUE_REF_NULL;
116
124
  repositories?: XenApiRepository['$ref'][];
117
- repository_proxy_password?: XenApiSecret['$ref'];
125
+ repository_proxy_password?: XenApiSecret['$ref'] | OPAQUE_REF_NULL;
118
126
  repository_proxy_url?: string;
119
127
  repository_proxy_username?: string;
120
128
  restrictions: Record<string, string>;
121
- suspend_image_SR?: XenApiSr['$ref'];
129
+ suspend_image_SR: XenApiSr['$ref'] | OPAQUE_REF_NULL;
122
130
  tags: string[];
123
131
  telemetry_frequency?: TELEMETRY_FREQUENCY;
124
132
  telemetry_next_collection?: string;
125
- telemetry_uuid?: XenApiSecret['$ref'];
133
+ telemetry_uuid?: XenApiSecret['$ref'] | OPAQUE_REF_NULL;
126
134
  tls_verification_enabled?: boolean;
127
135
  uefi_certificates?: string;
128
136
  update_sync_day?: number;
@@ -137,23 +145,23 @@ export interface XenApiPool {
137
145
  /** @deprecated */
138
146
  wlb_verify_cert?: boolean;
139
147
  }
148
+ export type XenApiPoolWrapped = WrapperXenApi<XenApiPool, 'pool'>;
149
+ /** @deprecated */
140
150
  export interface XenApiPoolPatch {
141
151
  $ref: Branded<'pool_patch'>;
142
- $type: 'pool_patch';
143
152
  after_apply_guidance: AFTER_APPLY_GUIDANCE[];
144
153
  host_patches: XenApiHostPatch['$ref'][];
145
154
  name_description: string;
146
155
  name_label: string;
147
156
  other_config: Record<string, string>;
148
157
  pool_applied: boolean;
149
- pool_update?: XenApiPoolUpdate['$ref'];
158
+ pool_update?: XenApiPoolUpdate['$ref'] | OPAQUE_REF_NULL;
150
159
  size: number;
151
160
  uuid: string;
152
161
  version: string;
153
162
  }
154
163
  export interface XenApiPoolUpdate {
155
164
  $ref: Branded<'pool_update'>;
156
- $type: 'pool_update';
157
165
  after_apply_guidance?: UPDATE_AFTER_APPLY_GUIDANCE[];
158
166
  enforce_homogeneity?: boolean;
159
167
  hosts?: XenApiHost['$ref'][];
@@ -163,19 +171,21 @@ export interface XenApiPoolUpdate {
163
171
  name_label: string;
164
172
  other_config?: Record<string, string>;
165
173
  uuid: string;
166
- vdi?: XenApiVdi['$ref'];
174
+ vdi: XenApiVdi['$ref'];
167
175
  version?: string;
168
176
  }
177
+ type XenApiVmCallMethods = {
178
+ (method: 'start', start_paused: boolean, force: boolean): Promise<void>;
179
+ };
169
180
  export interface XenApiVm {
170
181
  $ref: Branded<'VM'>;
171
- $type: 'VM';
172
- actions_after_crash?: ON_CRASH_BEHAVIOUR;
173
- actions_after_reboot?: ON_NORMAL_EXIT;
174
- actions_after_shutdown?: ON_NORMAL_EXIT;
182
+ actions_after_crash: ON_CRASH_BEHAVIOUR;
183
+ actions_after_reboot: ON_NORMAL_EXIT;
184
+ actions_after_shutdown: ON_NORMAL_EXIT;
175
185
  actions_after_softreboot?: ON_SOFTREBOOT_BEHAVIOR;
176
- affinity?: XenApiHost['$ref'];
186
+ affinity: XenApiHost['$ref'] | OPAQUE_REF_NULL;
177
187
  allowed_operations: VM_OPERATIONS[];
178
- appliance?: XenApiVmAppliance['$ref'];
188
+ appliance: XenApiVmAppliance['$ref'] | OPAQUE_REF_NULL;
179
189
  attached_PCIs: XenApiPci['$ref'][];
180
190
  bios_strings: Record<string, string>;
181
191
  blobs: Record<string, XenApiBlob['$ref']>;
@@ -185,80 +195,80 @@ export interface XenApiVm {
185
195
  crash_dumps: XenApiCrashdump['$ref'][];
186
196
  current_operations: Record<string, VM_OPERATIONS>;
187
197
  domain_type?: DOMAIN_TYPE;
188
- domarch?: string;
189
- domid?: number;
198
+ domarch: string;
199
+ domid: number;
190
200
  generation_id: string;
191
- guest_metrics?: XenApiVmGuestMetrics['$ref'];
201
+ guest_metrics: XenApiVmGuestMetrics['$ref'] | OPAQUE_REF_NULL;
192
202
  /** @deprecated */
193
203
  ha_always_run?: boolean;
194
204
  ha_restart_priority: string;
195
205
  hardware_platform_version: number;
196
206
  has_vendor_device: boolean;
197
- HVM_boot_params?: Record<string, string>;
207
+ HVM_boot_params: Record<string, string>;
198
208
  /** @deprecated */
199
209
  HVM_boot_policy?: string;
200
210
  HVM_shadow_multiplier: number;
201
211
  is_a_snapshot: boolean;
202
- is_a_template?: boolean;
203
- is_control_domain?: boolean;
212
+ is_a_template: boolean;
213
+ is_control_domain: boolean;
204
214
  is_default_template?: boolean;
205
215
  /** @deprecated */
206
216
  is_snapshot_from_vmpp?: boolean;
207
217
  is_vmss_snapshot?: boolean;
208
218
  last_boot_CPU_flags: Record<string, string>;
209
219
  last_booted_record: string;
210
- memory_dynamic_max?: number;
211
- memory_dynamic_min?: number;
220
+ memory_dynamic_max: number;
221
+ memory_dynamic_min: number;
212
222
  memory_overhead: number;
213
- memory_static_max?: number;
214
- memory_static_min?: number;
223
+ memory_static_max: number;
224
+ memory_static_min: number;
215
225
  /** @deprecated */
216
226
  memory_target?: number;
217
- metrics?: XenApiVmMetrics['$ref'];
227
+ metrics: XenApiVmMetrics['$ref'];
218
228
  name_description: string;
219
229
  name_label: string;
220
230
  NVRAM?: Record<string, string>;
221
231
  order: number;
222
- other_config?: Record<string, string>;
223
- parent?: XenApiVm['$ref'];
232
+ other_config: Record<string, string>;
233
+ parent: XenApiVm['$ref'] | OPAQUE_REF_NULL;
224
234
  /** @deprecated */
225
235
  PCI_bus?: string;
226
236
  pending_guidances_full?: UPDATE_GUIDANCES[];
227
237
  pending_guidances_recommended?: UPDATE_GUIDANCES[];
228
238
  pending_guidances?: UPDATE_GUIDANCES[];
229
- platform?: Record<string, string>;
239
+ platform: Record<string, string>;
230
240
  power_state: VM_POWER_STATE;
231
241
  /** @deprecated */
232
- protection_policy?: XenApiVmpp['$ref'];
233
- PV_args?: string;
234
- PV_bootloader_args?: string;
235
- PV_bootloader?: string;
236
- PV_kernel?: string;
237
- PV_legacy_args?: string;
238
- PV_ramdisk?: string;
239
- recommendations?: string;
242
+ protection_policy?: XenApiVmpp['$ref'] | OPAQUE_REF_NULL;
243
+ PV_args: string;
244
+ PV_bootloader_args: string;
245
+ PV_bootloader: string;
246
+ PV_kernel: string;
247
+ PV_legacy_args: string;
248
+ PV_ramdisk: string;
249
+ recommendations: string;
240
250
  reference_label?: string;
241
251
  requires_reboot?: boolean;
242
- resident_on?: XenApiHost['$ref'];
243
- scheduled_to_be_resident_on?: XenApiHost['$ref'];
252
+ resident_on: XenApiHost['$ref'] | OPAQUE_REF_NULL;
253
+ scheduled_to_be_resident_on: XenApiHost['$ref'] | OPAQUE_REF_NULL;
244
254
  shutdown_delay: number;
245
255
  snapshot_info: Record<string, string>;
246
256
  snapshot_metadata: string;
247
- snapshot_of?: XenApiVm['$ref'];
248
- snapshot_schedule?: XenApiVmss['$ref'];
257
+ snapshot_of: XenApiVm['$ref'] | OPAQUE_REF_NULL;
258
+ snapshot_schedule?: XenApiVmss['$ref'] | OPAQUE_REF_NULL;
249
259
  snapshot_time: string;
250
260
  snapshots: XenApiVm['$ref'][];
251
261
  start_delay: number;
252
- suspend_SR?: XenApiSr['$ref'];
253
- suspend_VDI?: XenApiVdi['$ref'];
262
+ suspend_SR: XenApiSr['$ref'] | OPAQUE_REF_NULL;
263
+ suspend_VDI: XenApiVdi['$ref'] | OPAQUE_REF_NULL;
254
264
  tags: string[];
255
265
  transportable_snapshot_id: string;
256
- user_version?: number;
266
+ user_version: number;
257
267
  uuid: string;
258
268
  VBDs: XenApiVbd['$ref'][];
259
- VCPUs_at_startup?: number;
260
- VCPUs_max?: number;
261
- VCPUs_params?: Record<string, string>;
269
+ VCPUs_at_startup: number;
270
+ VCPUs_max: number;
271
+ VCPUs_params: Record<string, string>;
262
272
  version: number;
263
273
  VGPUs: XenApiVgpu['$ref'][];
264
274
  VIFs: XenApiVif['$ref'][];
@@ -266,51 +276,50 @@ export interface XenApiVm {
266
276
  VUSBs: XenApiVusb['$ref'][];
267
277
  xenstore_data: Record<string, string>;
268
278
  }
279
+ export type XenApiVmWrapped = WrapperXenApi<XenApiVm, 'VM', XenApiVmCallMethods>;
269
280
  export interface XenApiVmMetrics {
270
281
  $ref: Branded<'VM_metrics'>;
271
- $type: 'VM_metrics';
272
282
  current_domain_type?: DOMAIN_TYPE;
273
283
  hvm?: boolean;
274
- install_time?: string;
275
- last_updated?: string;
276
- memory_actual?: number;
284
+ install_time: string;
285
+ last_updated: string;
286
+ memory_actual: number;
277
287
  nested_virt?: boolean;
278
288
  nomigrate?: boolean;
279
289
  other_config: Record<string, string>;
280
- start_time?: string;
290
+ start_time: string;
281
291
  state: string[];
282
292
  uuid: string;
283
- VCPUs_CPU?: Record<number, number>;
284
- VCPUs_flags?: Record<number, string[]>;
285
- VCPUs_number?: number;
286
- VCPUs_params?: Record<string, string>;
293
+ VCPUs_CPU: Record<number, number>;
294
+ VCPUs_flags: Record<number, string[]>;
295
+ VCPUs_number: number;
296
+ VCPUs_params: Record<string, string>;
287
297
  /** @deprecated */
288
298
  VCPUs_utilisation?: Record<number, number>;
289
299
  }
290
300
  export interface XenApiVmGuestMetrics {
291
301
  $ref: Branded<'VM_guest_metrics'>;
292
- $type: 'VM_guest_metrics';
293
302
  can_use_hotplug_vbd: TRISTATE_TYPE;
294
303
  can_use_hotplug_vif: TRISTATE_TYPE;
295
304
  /** @deprecated */
296
305
  disks?: Record<string, string>;
297
- last_updated?: string;
306
+ last_updated: string;
298
307
  live: boolean;
299
308
  /** @deprecated */
300
309
  memory?: Record<string, string>;
301
- networks?: Record<string, string>;
302
- os_version?: Record<string, string>;
310
+ networks: Record<string, string>;
311
+ os_version: Record<string, string>;
303
312
  other_config: Record<string, string>;
304
- other?: Record<string, string>;
313
+ other: Record<string, string>;
305
314
  PV_drivers_detected: boolean;
306
315
  /** @deprecated */
307
316
  PV_drivers_up_to_date?: boolean;
308
- PV_drivers_version?: Record<string, string>;
317
+ PV_drivers_version: Record<string, string>;
309
318
  uuid: string;
310
319
  }
320
+ /** @deprecated */
311
321
  export interface XenApiVmpp {
312
322
  $ref: Branded<'VMPP'>;
313
- $type: 'VMPP';
314
323
  /** @deprecated */
315
324
  alarm_config?: Record<string, string>;
316
325
  /** @deprecated */
@@ -346,27 +355,25 @@ export interface XenApiVmpp {
346
355
  /** @deprecated */
347
356
  recent_alerts?: string[];
348
357
  /** @deprecated */
349
- uuid: string;
358
+ uuid?: string;
350
359
  /** @deprecated */
351
360
  VMs?: XenApiVm['$ref'][];
352
361
  }
353
362
  export interface XenApiVmss {
354
363
  $ref: Branded<'VMSS'>;
355
- $type: 'VMSS';
356
364
  enabled: boolean;
357
- frequency?: VMSS_FREQUENCY;
365
+ frequency: VMSS_FREQUENCY;
358
366
  last_run_time: string;
359
367
  name_description: string;
360
368
  name_label: string;
361
369
  retained_snapshots: number;
362
370
  schedule: Record<string, string>;
363
- type?: VMSS_TYPE;
371
+ type: VMSS_TYPE;
364
372
  uuid: string;
365
373
  VMs: XenApiVm['$ref'][];
366
374
  }
367
375
  export interface XenApiVmAppliance {
368
376
  $ref: Branded<'VM_appliance'>;
369
- $type: 'VM_appliance';
370
377
  allowed_operations: VM_APPLIANCE_OPERATION[];
371
378
  current_operations: Record<string, VM_APPLIANCE_OPERATION>;
372
379
  name_description: string;
@@ -376,34 +383,32 @@ export interface XenApiVmAppliance {
376
383
  }
377
384
  export interface XenApiDrTask {
378
385
  $ref: Branded<'DR_task'>;
379
- $type: 'DR_task';
380
386
  introduced_SRs: XenApiSr['$ref'][];
381
387
  uuid: string;
382
388
  }
383
389
  export interface XenApiHost {
384
390
  $ref: Branded<'host'>;
385
- $type: 'host';
386
- address?: string;
391
+ address: string;
387
392
  allowed_operations: HOST_ALLOWED_OPERATIONS[];
388
- API_version_major?: number;
389
- API_version_minor?: number;
390
- API_version_vendor_implementation?: Record<string, string>;
391
- API_version_vendor?: string;
393
+ API_version_major: number;
394
+ API_version_minor: number;
395
+ API_version_vendor_implementation: Record<string, string>;
396
+ API_version_vendor: string;
392
397
  bios_strings: Record<string, string>;
393
398
  blobs: Record<string, XenApiBlob['$ref']>;
394
399
  capabilities: string[];
395
400
  certificates?: XenApiCertificate['$ref'][];
396
401
  chipset_info: Record<string, string>;
397
- control_domain?: XenApiVm['$ref'];
398
- cpu_configuration?: Record<string, string>;
402
+ control_domain?: XenApiVm['$ref'] | OPAQUE_REF_NULL;
403
+ cpu_configuration: Record<string, string>;
399
404
  cpu_info: Record<string, string>;
400
- crash_dump_sr?: XenApiSr['$ref'];
405
+ crash_dump_sr: XenApiSr['$ref'] | OPAQUE_REF_NULL;
401
406
  crashdumps: XenApiHostCrashdump['$ref'][];
402
407
  current_operations: Record<string, HOST_ALLOWED_OPERATIONS>;
403
408
  display: HOST_DISPLAY;
404
409
  edition: string;
405
410
  editions?: string[];
406
- enabled?: boolean;
411
+ enabled: boolean;
407
412
  external_auth_configuration: Record<string, string>;
408
413
  external_auth_service_name: string;
409
414
  external_auth_type: string;
@@ -412,23 +417,23 @@ export interface XenApiHost {
412
417
  ha_network_peers: string[];
413
418
  ha_statefiles: string[];
414
419
  host_CPUs: XenApiHostCpu['$ref'][];
415
- hostname?: string;
420
+ hostname: string;
416
421
  https_only?: boolean;
417
422
  iscsi_iqn?: string;
418
423
  last_software_update?: string;
419
424
  last_update_hash?: string;
420
425
  latest_synced_updates_applied?: LATEST_SYNCED_UPDATES_APPLIED_STATE;
421
- license_params?: Record<string, string>;
426
+ license_params: Record<string, string>;
422
427
  license_server: Record<string, string>;
423
- local_cache_sr?: XenApiSr['$ref'];
424
- logging?: Record<string, string>;
428
+ local_cache_sr: XenApiSr['$ref'] | OPAQUE_REF_NULL;
429
+ logging: Record<string, string>;
425
430
  memory_overhead: number;
426
- metrics?: XenApiHostMetrics['$ref'];
431
+ metrics: XenApiHostMetrics['$ref'];
427
432
  multipathing?: boolean;
428
433
  name_description: string;
429
434
  name_label: string;
430
435
  numa_affinity_policy?: HOST_NUMA_AFFINITY_POLICY;
431
- other_config?: Record<string, string>;
436
+ other_config: Record<string, string>;
432
437
  /** @deprecated */
433
438
  patches?: XenApiHostPatch['$ref'][];
434
439
  PBDs: XenApiPbd['$ref'][];
@@ -442,12 +447,12 @@ export interface XenApiHost {
442
447
  power_on_mode: string;
443
448
  PUSBs?: XenApiPusb['$ref'][];
444
449
  resident_VMs: XenApiVm['$ref'][];
445
- sched_policy?: string;
446
- software_version?: Record<string, string>;
450
+ sched_policy: string;
451
+ software_version: Record<string, string>;
447
452
  /** @deprecated */
448
453
  ssl_legacy?: boolean;
449
454
  supported_bootloaders: string[];
450
- suspend_image_sr?: XenApiSr['$ref'];
455
+ suspend_image_sr: XenApiSr['$ref'] | OPAQUE_REF_NULL;
451
456
  tags: string[];
452
457
  tls_verification_enabled?: boolean;
453
458
  /** @deprecated */
@@ -457,60 +462,58 @@ export interface XenApiHost {
457
462
  uuid: string;
458
463
  virtual_hardware_platform_versions: number[];
459
464
  }
465
+ export type XenApiHostWrapped = WrapperXenApi<XenApiHost, 'host'>;
460
466
  export interface XenApiHostCrashdump {
461
467
  $ref: Branded<'host_crashdump'>;
462
- $type: 'host_crashdump';
463
- host?: XenApiHost['$ref'];
468
+ host: XenApiHost['$ref'];
464
469
  other_config: Record<string, string>;
465
- size?: number;
466
- timestamp?: string;
470
+ size: number;
471
+ timestamp: string;
467
472
  uuid: string;
468
473
  }
474
+ /** @deprecated */
469
475
  export interface XenApiHostPatch {
470
476
  $ref: Branded<'host_patch'>;
471
- $type: 'host_patch';
472
- applied?: boolean;
473
- host?: XenApiHost['$ref'];
477
+ applied: boolean;
478
+ host: XenApiHost['$ref'];
474
479
  name_description: string;
475
480
  name_label: string;
476
481
  other_config: Record<string, string>;
477
- pool_patch?: XenApiPoolPatch['$ref'];
478
- size?: number;
479
- timestamp_applied?: string;
482
+ pool_patch: XenApiPoolPatch['$ref'] | OPAQUE_REF_NULL;
483
+ size: number;
484
+ timestamp_applied: string;
480
485
  uuid: string;
481
- version?: string;
486
+ version: string;
482
487
  }
483
488
  export interface XenApiHostMetrics {
484
489
  $ref: Branded<'host_metrics'>;
485
- $type: 'host_metrics';
486
- last_updated?: string;
487
- live?: boolean;
490
+ last_updated: string;
491
+ live: boolean;
488
492
  /** @deprecated */
489
493
  memory_free?: number;
490
- memory_total?: number;
494
+ memory_total: number;
491
495
  other_config: Record<string, string>;
492
496
  uuid: string;
493
497
  }
498
+ /** @deprecated */
494
499
  export interface XenApiHostCpu {
495
500
  $ref: Branded<'host_cpu'>;
496
- $type: 'host_cpu';
497
- family?: number;
498
- features?: string;
499
- flags?: string;
500
- host?: XenApiHost['$ref'];
501
- model?: number;
502
- modelname?: string;
503
- number?: number;
501
+ family: number;
502
+ features: string;
503
+ flags: string;
504
+ host: XenApiHost['$ref'];
505
+ model: number;
506
+ modelname: string;
507
+ number: number;
504
508
  other_config: Record<string, string>;
505
- speed?: number;
506
- stepping?: string;
507
- utilisation?: number;
509
+ speed: number;
510
+ stepping: string;
511
+ utilisation: number;
508
512
  uuid: string;
509
- vendor?: string;
513
+ vendor: string;
510
514
  }
511
515
  export interface XenApiNetwork {
512
516
  $ref: Branded<'network'>;
513
- $type: 'network';
514
517
  allowed_operations: NETWORK_OPERATIONS[];
515
518
  assigned_ips: Record<XenApiVif['$ref'], string>;
516
519
  blobs: Record<string, XenApiBlob['$ref']>;
@@ -521,7 +524,7 @@ export interface XenApiNetwork {
521
524
  MTU: number;
522
525
  name_description: string;
523
526
  name_label: string;
524
- other_config?: Record<string, string>;
527
+ other_config: Record<string, string>;
525
528
  PIFs: XenApiPif['$ref'][];
526
529
  purpose?: NETWORK_PURPOSE[];
527
530
  tags: string[];
@@ -530,11 +533,10 @@ export interface XenApiNetwork {
530
533
  }
531
534
  export interface XenApiVif {
532
535
  $ref: Branded<'VIF'>;
533
- $type: 'VIF';
534
536
  allowed_operations: VIF_OPERATIONS[];
535
537
  current_operations: Record<string, VIF_OPERATIONS>;
536
538
  currently_attached: boolean;
537
- device?: string;
539
+ device: string;
538
540
  ipv4_addresses: string[];
539
541
  ipv4_allowed: string[];
540
542
  ipv4_configuration_mode: VIF_IPV4_CONFIGURATION_MODE;
@@ -545,59 +547,59 @@ export interface XenApiVif {
545
547
  ipv6_gateway: string;
546
548
  locking_mode: VIF_LOCKING_MODE;
547
549
  MAC_autogenerated: boolean;
548
- MAC?: string;
550
+ MAC: string;
549
551
  /** @deprecated */
550
- metrics?: XenApiVifMetrics['$ref'];
551
- MTU?: number;
552
- network?: XenApiNetwork['$ref'];
553
- other_config?: Record<string, string>;
554
- qos_algorithm_params?: Record<string, string>;
555
- qos_algorithm_type?: string;
552
+ metrics?: XenApiVifMetrics['$ref'] | OPAQUE_REF_NULL;
553
+ MTU: number;
554
+ network: XenApiNetwork['$ref'];
555
+ other_config: Record<string, string>;
556
+ qos_algorithm_params: Record<string, string>;
557
+ qos_algorithm_type: string;
556
558
  qos_supported_algorithms: string[];
557
- runtime_properties?: Record<string, string>;
558
- status_code?: number;
559
- status_detail?: string;
559
+ runtime_properties: Record<string, string>;
560
+ status_code: number;
561
+ status_detail: string;
560
562
  uuid: string;
561
- VM?: XenApiVm['$ref'];
563
+ VM: XenApiVm['$ref'];
562
564
  }
565
+ export type XenApiVifWrapped = WrapperXenApi<XenApiVif, 'VIF'>;
566
+ /** @deprecated */
563
567
  export interface XenApiVifMetrics {
564
568
  $ref: Branded<'VIF_metrics'>;
565
- $type: 'VIF_metrics';
566
569
  /** @deprecated */
567
570
  io_read_kbs?: number;
568
571
  /** @deprecated */
569
572
  io_write_kbs?: number;
570
- last_updated?: string;
573
+ last_updated: string;
571
574
  other_config: Record<string, string>;
572
575
  uuid: string;
573
576
  }
574
577
  export interface XenApiPif {
575
578
  $ref: Branded<'PIF'>;
576
- $type: 'PIF';
577
579
  bond_master_of: XenApiBond['$ref'][];
578
- bond_slave_of?: XenApiBond['$ref'];
580
+ bond_slave_of: XenApiBond['$ref'] | OPAQUE_REF_NULL;
579
581
  capabilities: string[];
580
582
  currently_attached: boolean;
581
- device?: string;
583
+ device: string;
582
584
  disallow_unplug: boolean;
583
585
  DNS: string;
584
586
  gateway: string;
585
- host?: XenApiHost['$ref'];
587
+ host: XenApiHost['$ref'];
586
588
  igmp_snooping_status?: PIF_IGMP_STATUS;
587
589
  ip_configuration_mode: IP_CONFIGURATION_MODE;
588
590
  IP: string;
589
591
  ipv6_configuration_mode: IPV6_CONFIGURATION_MODE;
590
592
  ipv6_gateway: string;
591
593
  IPv6: string[];
592
- MAC?: string;
594
+ MAC: string;
593
595
  managed: boolean;
594
596
  management: boolean;
595
- metrics?: XenApiPifMetrics['$ref'];
596
- MTU?: number;
597
+ metrics: XenApiPifMetrics['$ref'];
598
+ MTU: number;
597
599
  netmask: string;
598
- network?: XenApiNetwork['$ref'];
600
+ network: XenApiNetwork['$ref'];
599
601
  other_config: Record<string, string>;
600
- PCI?: XenApiPci['$ref'];
602
+ PCI?: XenApiPci['$ref'] | OPAQUE_REF_NULL;
601
603
  physical: boolean;
602
604
  primary_address_type: PRIMARY_ADDRESS_TYPE;
603
605
  properties: Record<string, string>;
@@ -606,109 +608,103 @@ export interface XenApiPif {
606
608
  tunnel_access_PIF_of: XenApiTunnel['$ref'][];
607
609
  tunnel_transport_PIF_of: XenApiTunnel['$ref'][];
608
610
  uuid: string;
609
- VLAN_master_of?: XenApiVlan['$ref'];
611
+ VLAN_master_of: XenApiVlan['$ref'] | OPAQUE_REF_NULL;
610
612
  VLAN_slave_of: XenApiVlan['$ref'][];
611
- VLAN?: number;
613
+ VLAN: number;
612
614
  }
613
615
  export interface XenApiPifMetrics {
614
616
  $ref: Branded<'PIF_metrics'>;
615
- $type: 'PIF_metrics';
616
- carrier?: boolean;
617
- device_id?: string;
618
- device_name?: string;
619
- duplex?: boolean;
617
+ carrier: boolean;
618
+ device_id: string;
619
+ device_name: string;
620
+ duplex: boolean;
620
621
  /** @deprecated */
621
622
  io_read_kbs?: number;
622
623
  /** @deprecated */
623
624
  io_write_kbs?: number;
624
- last_updated?: string;
625
+ last_updated: string;
625
626
  other_config: Record<string, string>;
626
- pci_bus_path?: string;
627
- speed?: number;
627
+ pci_bus_path: string;
628
+ speed: number;
628
629
  uuid: string;
629
- vendor_id?: string;
630
- vendor_name?: string;
630
+ vendor_id: string;
631
+ vendor_name: string;
631
632
  }
632
633
  export interface XenApiBond {
633
634
  $ref: Branded<'Bond'>;
634
- $type: 'Bond';
635
635
  auto_update_mac?: boolean;
636
636
  links_up: number;
637
- master?: XenApiPif['$ref'];
637
+ master: XenApiPif['$ref'] | OPAQUE_REF_NULL;
638
638
  mode: BOND_MODE;
639
639
  other_config: Record<string, string>;
640
- primary_slave?: XenApiPif['$ref'];
640
+ primary_slave: XenApiPif['$ref'] | OPAQUE_REF_NULL;
641
641
  properties: Record<string, string>;
642
642
  slaves: XenApiPif['$ref'][];
643
643
  uuid: string;
644
644
  }
645
645
  export interface XenApiVlan {
646
646
  $ref: Branded<'VLAN'>;
647
- $type: 'VLAN';
648
647
  other_config: Record<string, string>;
649
648
  tag: number;
650
- tagged_PIF?: XenApiPif['$ref'];
651
- untagged_PIF?: XenApiPif['$ref'];
649
+ tagged_PIF: XenApiPif['$ref'] | OPAQUE_REF_NULL;
650
+ untagged_PIF: XenApiPif['$ref'] | OPAQUE_REF_NULL;
652
651
  uuid: string;
653
652
  }
654
653
  export interface XenApiSm {
655
654
  $ref: Branded<'SM'>;
656
- $type: 'SM';
657
655
  /** @deprecated */
658
656
  capabilities?: string[];
659
- configuration?: Record<string, string>;
660
- copyright?: string;
657
+ configuration: Record<string, string>;
658
+ copyright: string;
661
659
  driver_filename: string;
662
660
  features: Record<string, number>;
663
661
  name_description: string;
664
662
  name_label: string;
665
663
  other_config: Record<string, string>;
666
- required_api_version?: string;
664
+ required_api_version: string;
667
665
  required_cluster_stack: string[];
668
- type?: string;
666
+ type: string;
669
667
  uuid: string;
670
- vendor?: string;
671
- version?: string;
668
+ vendor: string;
669
+ version: string;
672
670
  }
673
671
  export interface XenApiSr {
674
672
  $ref: Branded<'SR'>;
675
- $type: 'SR';
676
673
  allowed_operations: STORAGE_OPERATIONS[];
677
674
  blobs: Record<string, XenApiBlob['$ref']>;
678
675
  clustered: boolean;
679
- content_type?: string;
676
+ content_type: string;
680
677
  current_operations: Record<string, STORAGE_OPERATIONS>;
681
- introduced_by?: XenApiDrTask['$ref'];
678
+ introduced_by: XenApiDrTask['$ref'] | OPAQUE_REF_NULL;
682
679
  is_tools_sr: boolean;
683
680
  local_cache_enabled: boolean;
684
681
  name_description: string;
685
682
  name_label: string;
686
- other_config?: Record<string, string>;
683
+ other_config: Record<string, string>;
687
684
  PBDs: XenApiPbd['$ref'][];
688
- physical_size?: number;
689
- physical_utilisation?: number;
690
- shared?: boolean;
685
+ physical_size: number;
686
+ physical_utilisation: number;
687
+ shared: boolean;
691
688
  sm_config: Record<string, string>;
692
689
  tags: string[];
693
- type?: string;
690
+ type: string;
694
691
  uuid: string;
695
692
  VDIs: XenApiVdi['$ref'][];
696
- virtual_allocation?: number;
693
+ virtual_allocation: number;
697
694
  }
695
+ export type XenApiSrWrapped = WrapperXenApi<XenApiSr, 'SR'>;
698
696
  export interface XenApiSrStat {
699
697
  $ref: Branded<'sr_stat'>;
700
- $type: 'sr_stat';
701
698
  clustered?: boolean;
702
699
  free_space?: number;
703
700
  health?: SR_HEALTH;
704
701
  name_description?: string;
705
702
  name_label?: string;
706
703
  total_space?: number;
707
- uuid: unknown;
704
+ uuid?: unknown;
708
705
  }
709
706
  export interface XenApiProbeResult {
710
707
  $ref: Branded<'probe_result'>;
711
- $type: 'probe_result';
712
708
  complete?: boolean;
713
709
  configuration?: Record<string, string>;
714
710
  extra_info?: Record<string, string>;
@@ -716,12 +712,10 @@ export interface XenApiProbeResult {
716
712
  }
717
713
  export interface XenApiLvhd {
718
714
  $ref: Branded<'LVHD'>;
719
- $type: 'LVHD';
720
715
  uuid: string;
721
716
  }
722
717
  export interface XenApiVdi {
723
718
  $ref: Branded<'VDI'>;
724
- $type: 'VDI';
725
719
  allow_caching: boolean;
726
720
  allowed_operations: VDI_OPERATIONS[];
727
721
  cbt_enabled?: boolean;
@@ -730,62 +724,63 @@ export interface XenApiVdi {
730
724
  is_a_snapshot: boolean;
731
725
  is_tools_iso: boolean;
732
726
  location: string;
733
- managed?: boolean;
727
+ managed: boolean;
734
728
  metadata_latest: boolean;
735
- metadata_of_pool?: XenApiPool['$ref'];
736
- missing?: boolean;
729
+ metadata_of_pool: XenApiPool['$ref'] | OPAQUE_REF_NULL;
730
+ missing: boolean;
737
731
  name_description: string;
738
732
  name_label: string;
739
733
  on_boot: ON_BOOT;
740
- other_config?: Record<string, string>;
734
+ other_config: Record<string, string>;
741
735
  /** @deprecated */
742
- parent?: XenApiVdi['$ref'];
743
- physical_utilisation?: number;
744
- read_only?: boolean;
745
- sharable?: boolean;
736
+ parent?: OPAQUE_REF_NULL;
737
+ physical_utilisation: number;
738
+ read_only: boolean;
739
+ sharable: boolean;
746
740
  sm_config: Record<string, string>;
747
- snapshot_of?: XenApiVdi['$ref'];
741
+ snapshot_of: XenApiVdi['$ref'] | OPAQUE_REF_NULL;
748
742
  snapshot_time: string;
749
743
  snapshots: XenApiVdi['$ref'][];
750
- SR?: XenApiSr['$ref'];
751
- storage_lock?: boolean;
744
+ SR: XenApiSr['$ref'];
745
+ storage_lock: boolean;
752
746
  tags: string[];
753
- type?: VDI_TYPE;
747
+ type: VDI_TYPE;
754
748
  uuid: string;
755
749
  VBDs: XenApiVbd['$ref'][];
756
- virtual_size?: number;
750
+ virtual_size: number;
757
751
  xenstore_data: Record<string, string>;
758
752
  }
753
+ export type XenApiVdiWrapped = WrapperXenApi<XenApiVdi, 'VDI'>;
759
754
  export interface XenApiVbd {
760
755
  $ref: Branded<'VBD'>;
761
- $type: 'VBD';
762
756
  allowed_operations: VBD_OPERATIONS[];
763
- bootable?: boolean;
757
+ bootable: boolean;
764
758
  current_operations: Record<string, VBD_OPERATIONS>;
765
759
  currently_attached: boolean;
766
760
  device: string;
767
- empty?: boolean;
761
+ empty: boolean;
768
762
  /** @deprecated */
769
- metrics?: XenApiVbdMetrics['$ref'];
770
- mode?: VBD_MODE;
771
- other_config?: Record<string, string>;
772
- qos_algorithm_params?: Record<string, string>;
773
- qos_algorithm_type?: string;
763
+ metrics?: XenApiVbdMetrics['$ref'] | OPAQUE_REF_NULL;
764
+ mode: VBD_MODE;
765
+ other_config: Record<string, string>;
766
+ qos_algorithm_params: Record<string, string>;
767
+ qos_algorithm_type: string;
774
768
  qos_supported_algorithms: string[];
775
- runtime_properties?: Record<string, string>;
776
- status_code?: number;
777
- status_detail?: string;
778
- storage_lock?: boolean;
779
- type?: VBD_TYPE;
769
+ runtime_properties: Record<string, string>;
770
+ status_code: number;
771
+ status_detail: string;
772
+ storage_lock: boolean;
773
+ type: VBD_TYPE;
780
774
  unpluggable: boolean;
781
- userdevice?: string;
775
+ userdevice: string;
782
776
  uuid: string;
783
- VDI?: XenApiVdi['$ref'];
784
- VM?: XenApiVm['$ref'];
777
+ VDI: XenApiVdi['$ref'];
778
+ VM: XenApiVm['$ref'];
785
779
  }
780
+ export type XenApiVbdWrapped = WrapperXenApi<XenApiVbd, 'VBD'>;
781
+ /** @deprecated */
786
782
  export interface XenApiVbdMetrics {
787
783
  $ref: Branded<'VBD_metrics'>;
788
- $type: 'VBD_metrics';
789
784
  /** @deprecated */
790
785
  io_read_kbs?: number;
791
786
  /** @deprecated */
@@ -798,119 +793,110 @@ export interface XenApiVbdMetrics {
798
793
  }
799
794
  export interface XenApiPbd {
800
795
  $ref: Branded<'PBD'>;
801
- $type: 'PBD';
802
- currently_attached?: boolean;
803
- device_config?: Record<string, string>;
804
- host?: XenApiHost['$ref'];
796
+ currently_attached: boolean;
797
+ device_config: Record<string, string>;
798
+ host: XenApiHost['$ref'];
805
799
  other_config: Record<string, string>;
806
- SR?: XenApiSr['$ref'];
800
+ SR: XenApiSr['$ref'];
807
801
  uuid: string;
808
802
  }
803
+ /** @deprecated */
809
804
  export interface XenApiCrashdump {
810
805
  $ref: Branded<'crashdump'>;
811
- $type: 'crashdump';
812
806
  other_config: Record<string, string>;
813
807
  uuid: string;
814
- VDI?: XenApiVdi['$ref'];
815
- VM?: XenApiVm['$ref'];
808
+ VDI: XenApiVdi['$ref'];
809
+ VM: XenApiVm['$ref'];
816
810
  }
817
811
  export interface XenApiVtpm {
818
812
  $ref: Branded<'VTPM'>;
819
- $type: 'VTPM';
820
813
  allowed_operations: VTPM_OPERATIONS[];
821
- backend?: XenApiVm['$ref'];
814
+ backend: XenApiVm['$ref'] | OPAQUE_REF_NULL;
822
815
  current_operations: Record<string, VTPM_OPERATIONS>;
823
816
  is_protected?: boolean;
824
817
  is_unique?: boolean;
825
818
  persistence_backend?: PERSISTENCE_BACKEND;
826
819
  uuid: string;
827
- VM?: XenApiVm['$ref'];
820
+ VM: XenApiVm['$ref'];
828
821
  }
822
+ export type XenApiVtpmWrapped = WrapperXenApi<XenApiVtpm, 'VTPM'>;
829
823
  export interface XenApiConsole {
830
824
  $ref: Branded<'console'>;
831
- $type: 'console';
832
- location?: string;
833
- other_config?: Record<string, string>;
834
- protocol?: CONSOLE_PROTOCOL;
825
+ location: string;
826
+ other_config: Record<string, string>;
827
+ protocol: CONSOLE_PROTOCOL;
835
828
  uuid: string;
836
- VM?: XenApiVm['$ref'];
829
+ VM: XenApiVm['$ref'];
837
830
  }
831
+ /** @deprecated */
838
832
  export interface XenApiUser {
839
833
  $ref: Branded<'user'>;
840
- $type: 'user';
841
- fullname?: string;
834
+ fullname: string;
842
835
  other_config: Record<string, string>;
843
- short_name?: string;
836
+ short_name: string;
844
837
  uuid: string;
845
838
  }
846
839
  export interface XenApiDataSource {
847
840
  $ref: Branded<'data_source'>;
848
- $type: 'data_source';
849
- enabled?: boolean;
850
- max?: number;
851
- min?: number;
841
+ enabled: boolean;
842
+ max: number;
843
+ min: number;
852
844
  name_description: string;
853
845
  name_label: string;
854
- standard?: boolean;
855
- units?: string;
856
- value?: number;
846
+ standard: boolean;
847
+ units: string;
848
+ value: number;
857
849
  }
858
850
  export interface XenApiBlob {
859
851
  $ref: Branded<'blob'>;
860
- $type: 'blob';
861
- last_updated?: string;
862
- mime_type?: string;
852
+ last_updated: string;
853
+ mime_type: string;
863
854
  name_description: string;
864
855
  name_label: string;
865
856
  public: boolean;
866
- size?: number;
857
+ size: number;
867
858
  uuid: string;
868
859
  }
869
860
  export interface XenApiMessage {
870
861
  $ref: Branded<'message'>;
871
- $type: 'message';
872
- body?: string;
873
- cls?: CLS;
874
- name?: string;
875
- obj_uuid?: string;
876
- priority?: number;
877
- timestamp?: string;
862
+ body: string;
863
+ cls: CLS;
864
+ name: string;
865
+ obj_uuid: string;
866
+ priority: number;
867
+ timestamp: string;
878
868
  uuid: string;
879
869
  }
880
870
  export interface XenApiSecret {
881
871
  $ref: Branded<'secret'>;
882
- $type: 'secret';
883
872
  other_config: Record<string, string>;
884
873
  uuid: string;
885
- value?: string;
874
+ value: string;
886
875
  }
887
876
  export interface XenApiTunnel {
888
877
  $ref: Branded<'tunnel'>;
889
- $type: 'tunnel';
890
- access_PIF?: XenApiPif['$ref'];
878
+ access_PIF: XenApiPif['$ref'] | OPAQUE_REF_NULL;
891
879
  other_config: Record<string, string>;
892
880
  protocol?: TUNNEL_PROTOCOL;
893
881
  status: Record<string, string>;
894
- transport_PIF?: XenApiPif['$ref'];
882
+ transport_PIF: XenApiPif['$ref'] | OPAQUE_REF_NULL;
895
883
  uuid: string;
896
884
  }
897
885
  export interface XenApiNetworkSriov {
898
886
  $ref: Branded<'network_sriov'>;
899
- $type: 'network_sriov';
900
887
  configuration_mode?: SRIOV_CONFIGURATION_MODE;
901
- logical_PIF?: XenApiPif['$ref'];
902
- physical_PIF?: XenApiPif['$ref'];
888
+ logical_PIF?: XenApiPif['$ref'] | OPAQUE_REF_NULL;
889
+ physical_PIF?: XenApiPif['$ref'] | OPAQUE_REF_NULL;
903
890
  requires_reboot?: boolean;
904
891
  uuid: string;
905
892
  }
906
893
  export interface XenApiPci {
907
894
  $ref: Branded<'PCI'>;
908
- $type: 'PCI';
909
895
  class_name: string;
910
896
  dependencies: XenApiPci['$ref'][];
911
897
  device_name: string;
912
898
  driver_name?: string;
913
- host?: XenApiHost['$ref'];
899
+ host: XenApiHost['$ref'] | OPAQUE_REF_NULL;
914
900
  other_config: Record<string, string>;
915
901
  pci_id: string;
916
902
  subsystem_device_name?: string;
@@ -920,15 +906,14 @@ export interface XenApiPci {
920
906
  }
921
907
  export interface XenApiPgpu {
922
908
  $ref: Branded<'PGPU'>;
923
- $type: 'PGPU';
924
909
  compatibility_metadata?: Record<string, string>;
925
910
  dom0_access: PGPU_DOM0_ACCESS;
926
911
  enabled_VGPU_types: XenApiVgpuType['$ref'][];
927
- GPU_group?: XenApiGpuGroup['$ref'];
928
- host?: XenApiHost['$ref'];
912
+ GPU_group: XenApiGpuGroup['$ref'] | OPAQUE_REF_NULL;
913
+ host: XenApiHost['$ref'] | OPAQUE_REF_NULL;
929
914
  is_system_display_device: boolean;
930
915
  other_config: Record<string, string>;
931
- PCI?: XenApiPci['$ref'];
916
+ PCI: XenApiPci['$ref'] | OPAQUE_REF_NULL;
932
917
  resident_VGPUs: XenApiVgpu['$ref'][];
933
918
  supported_VGPU_max_capacities: Record<XenApiVgpuType['$ref'], number>;
934
919
  supported_VGPU_types: XenApiVgpuType['$ref'][];
@@ -936,7 +921,6 @@ export interface XenApiPgpu {
936
921
  }
937
922
  export interface XenApiGpuGroup {
938
923
  $ref: Branded<'GPU_group'>;
939
- $type: 'GPU_group';
940
924
  allocation_algorithm: ALLOCATION_ALGORITHM;
941
925
  enabled_VGPU_types: XenApiVgpuType['$ref'][];
942
926
  GPU_types: string[];
@@ -950,23 +934,22 @@ export interface XenApiGpuGroup {
950
934
  }
951
935
  export interface XenApiVgpu {
952
936
  $ref: Branded<'VGPU'>;
953
- $type: 'VGPU';
954
937
  compatibility_metadata?: Record<string, string>;
955
938
  currently_attached: boolean;
956
939
  device: string;
957
940
  extra_args?: string;
958
- GPU_group?: XenApiGpuGroup['$ref'];
941
+ GPU_group: XenApiGpuGroup['$ref'];
959
942
  other_config: Record<string, string>;
960
- PCI?: XenApiPci['$ref'];
961
- resident_on?: XenApiPgpu['$ref'];
962
- scheduled_to_be_resident_on?: XenApiPgpu['$ref'];
963
- type?: XenApiVgpuType['$ref'];
943
+ PCI?: XenApiPci['$ref'] | OPAQUE_REF_NULL;
944
+ resident_on: XenApiPgpu['$ref'] | OPAQUE_REF_NULL;
945
+ scheduled_to_be_resident_on: XenApiPgpu['$ref'] | OPAQUE_REF_NULL;
946
+ type: XenApiVgpuType['$ref'] | OPAQUE_REF_NULL;
964
947
  uuid: string;
965
- VM?: XenApiVm['$ref'];
948
+ VM: XenApiVm['$ref'];
966
949
  }
950
+ export type XenApiVgpuWrapped = WrapperXenApi<XenApiVgpu, 'VGPU'>;
967
951
  export interface XenApiVgpuType {
968
952
  $ref: Branded<'VGPU_type'>;
969
- $type: 'VGPU_type';
970
953
  compatible_types_in_vm?: XenApiVgpuType['$ref'][];
971
954
  enabled_on_GPU_groups: XenApiGpuGroup['$ref'][];
972
955
  enabled_on_PGPUs: XenApiPgpu['$ref'][];
@@ -986,65 +969,58 @@ export interface XenApiVgpuType {
986
969
  }
987
970
  export interface XenApiPvsSite {
988
971
  $ref: Branded<'PVS_site'>;
989
- $type: 'PVS_site';
990
972
  cache_storage?: XenApiPvsCacheStorage['$ref'][];
991
973
  name_description?: string;
992
974
  name_label?: string;
993
975
  proxies?: XenApiPvsProxy['$ref'][];
994
976
  PVS_uuid?: string;
995
977
  servers?: XenApiPvsServer['$ref'][];
996
- uuid: string;
978
+ uuid?: string;
997
979
  }
998
980
  export interface XenApiPvsServer {
999
981
  $ref: Branded<'PVS_server'>;
1000
- $type: 'PVS_server';
1001
982
  addresses?: string[];
1002
983
  first_port?: number;
1003
984
  last_port?: number;
1004
- site?: XenApiPvsSite['$ref'];
1005
- uuid: string;
985
+ site?: XenApiPvsSite['$ref'] | OPAQUE_REF_NULL;
986
+ uuid?: string;
1006
987
  }
1007
988
  export interface XenApiPvsProxy {
1008
989
  $ref: Branded<'PVS_proxy'>;
1009
- $type: 'PVS_proxy';
1010
990
  currently_attached?: boolean;
1011
- site?: XenApiPvsSite['$ref'];
991
+ site?: XenApiPvsSite['$ref'] | OPAQUE_REF_NULL;
1012
992
  status?: PVS_PROXY_STATUS;
1013
- uuid: string;
1014
- VIF?: XenApiVif['$ref'];
993
+ uuid?: string;
994
+ VIF?: XenApiVif['$ref'] | OPAQUE_REF_NULL;
1015
995
  }
1016
996
  export interface XenApiPvsCacheStorage {
1017
997
  $ref: Branded<'PVS_cache_storage'>;
1018
- $type: 'PVS_cache_storage';
1019
- host?: XenApiHost['$ref'];
1020
- site?: XenApiPvsSite['$ref'];
998
+ host?: XenApiHost['$ref'] | OPAQUE_REF_NULL;
999
+ site?: XenApiPvsSite['$ref'] | OPAQUE_REF_NULL;
1021
1000
  size?: number;
1022
- SR?: XenApiSr['$ref'];
1023
- uuid: string;
1024
- VDI?: XenApiVdi['$ref'];
1001
+ SR?: XenApiSr['$ref'] | OPAQUE_REF_NULL;
1002
+ uuid?: string;
1003
+ VDI?: XenApiVdi['$ref'] | OPAQUE_REF_NULL;
1025
1004
  }
1026
1005
  export interface XenApiFeature {
1027
1006
  $ref: Branded<'Feature'>;
1028
- $type: 'Feature';
1029
1007
  enabled?: boolean;
1030
1008
  experimental?: boolean;
1031
1009
  host?: XenApiHost['$ref'];
1032
1010
  name_description: string;
1033
1011
  name_label: string;
1034
- uuid: string;
1012
+ uuid?: string;
1035
1013
  version?: string;
1036
1014
  }
1037
1015
  export interface XenApiSdnController {
1038
1016
  $ref: Branded<'SDN_controller'>;
1039
- $type: 'SDN_controller';
1040
1017
  address?: string;
1041
1018
  port?: number;
1042
1019
  protocol?: SDN_CONTROLLER_PROTOCOL;
1043
- uuid: string;
1020
+ uuid?: string;
1044
1021
  }
1045
1022
  export interface XenApiVdiNbdServerInfo {
1046
1023
  $ref: Branded<'vdi_nbd_server_info'>;
1047
- $type: 'vdi_nbd_server_info';
1048
1024
  address?: string;
1049
1025
  cert?: string;
1050
1026
  exportname?: string;
@@ -1053,9 +1029,8 @@ export interface XenApiVdiNbdServerInfo {
1053
1029
  }
1054
1030
  export interface XenApiPusb {
1055
1031
  $ref: Branded<'PUSB'>;
1056
- $type: 'PUSB';
1057
1032
  description?: string;
1058
- host?: XenApiHost['$ref'];
1033
+ host?: XenApiHost['$ref'] | OPAQUE_REF_NULL;
1059
1034
  other_config?: Record<string, string>;
1060
1035
  passthrough_enabled?: boolean;
1061
1036
  path?: string;
@@ -1063,36 +1038,33 @@ export interface XenApiPusb {
1063
1038
  product_id?: string;
1064
1039
  serial?: string;
1065
1040
  speed?: number;
1066
- USB_group?: XenApiUsbGroup['$ref'];
1067
- uuid: string;
1041
+ USB_group?: XenApiUsbGroup['$ref'] | OPAQUE_REF_NULL;
1042
+ uuid?: string;
1068
1043
  vendor_desc?: string;
1069
1044
  vendor_id?: string;
1070
1045
  version?: string;
1071
1046
  }
1072
1047
  export interface XenApiUsbGroup {
1073
1048
  $ref: Branded<'USB_group'>;
1074
- $type: 'USB_group';
1075
1049
  name_description?: string;
1076
1050
  name_label?: string;
1077
1051
  other_config?: Record<string, string>;
1078
1052
  PUSBs?: XenApiPusb['$ref'][];
1079
- uuid: string;
1053
+ uuid?: string;
1080
1054
  VUSBs?: XenApiVusb['$ref'][];
1081
1055
  }
1082
1056
  export interface XenApiVusb {
1083
1057
  $ref: Branded<'VUSB'>;
1084
- $type: 'VUSB';
1085
1058
  allowed_operations: VUSB_OPERATIONS[];
1086
1059
  current_operations: Record<string, VUSB_OPERATIONS>;
1087
1060
  currently_attached: boolean;
1088
1061
  other_config?: Record<string, string>;
1089
1062
  USB_group?: XenApiUsbGroup['$ref'];
1090
- uuid: string;
1063
+ uuid?: string;
1091
1064
  VM?: XenApiVm['$ref'];
1092
1065
  }
1093
1066
  export interface XenApiCluster {
1094
1067
  $ref: Branded<'Cluster'>;
1095
- $type: 'Cluster';
1096
1068
  allowed_operations: CLUSTER_OPERATION[];
1097
1069
  cluster_config?: Record<string, string>;
1098
1070
  cluster_hosts?: XenApiClusterHost['$ref'][];
@@ -1107,37 +1079,34 @@ export interface XenApiCluster {
1107
1079
  quorum?: number;
1108
1080
  token_timeout_coefficient?: number;
1109
1081
  token_timeout?: number;
1110
- uuid: string;
1082
+ uuid?: string;
1111
1083
  }
1112
1084
  export interface XenApiClusterHost {
1113
1085
  $ref: Branded<'Cluster_host'>;
1114
- $type: 'Cluster_host';
1115
1086
  allowed_operations: CLUSTER_HOST_OPERATION[];
1116
- cluster?: XenApiCluster['$ref'];
1087
+ cluster?: XenApiCluster['$ref'] | OPAQUE_REF_NULL;
1117
1088
  current_operations: Record<string, CLUSTER_HOST_OPERATION>;
1118
1089
  enabled?: boolean;
1119
- host?: XenApiHost['$ref'];
1090
+ host?: XenApiHost['$ref'] | OPAQUE_REF_NULL;
1120
1091
  joined?: boolean;
1121
1092
  last_update_live?: string;
1122
1093
  live?: boolean;
1123
1094
  other_config?: Record<string, string>;
1124
- PIF?: XenApiPif['$ref'];
1125
- uuid: string;
1095
+ PIF?: XenApiPif['$ref'] | OPAQUE_REF_NULL;
1096
+ uuid?: string;
1126
1097
  }
1127
1098
  export interface XenApiCertificate {
1128
1099
  $ref: Branded<'Certificate'>;
1129
- $type: 'Certificate';
1130
1100
  fingerprint?: string;
1131
- host?: XenApiHost['$ref'];
1101
+ host?: XenApiHost['$ref'] | OPAQUE_REF_NULL;
1132
1102
  name?: string;
1133
1103
  not_after?: string;
1134
1104
  not_before?: string;
1135
1105
  type?: CERTIFICATE_TYPE;
1136
- uuid: string;
1106
+ uuid?: string;
1137
1107
  }
1138
1108
  export interface XenApiRepository {
1139
1109
  $ref: Branded<'Repository'>;
1140
- $type: 'Repository';
1141
1110
  binary_url?: string;
1142
1111
  gpgkey_path?: string;
1143
1112
  hash?: string;
@@ -1147,11 +1116,10 @@ export interface XenApiRepository {
1147
1116
  /** @deprecated */
1148
1117
  up_to_date?: boolean;
1149
1118
  update?: boolean;
1150
- uuid: string;
1119
+ uuid?: string;
1151
1120
  }
1152
1121
  export interface XenApiObserver {
1153
1122
  $ref: Branded<'Observer'>;
1154
- $type: 'Observer';
1155
1123
  attributes?: Record<string, string>;
1156
1124
  components?: string[];
1157
1125
  enabled?: boolean;
@@ -1159,6 +1127,8 @@ export interface XenApiObserver {
1159
1127
  hosts?: XenApiHost['$ref'][];
1160
1128
  name_description: string;
1161
1129
  name_label: string;
1162
- uuid: string;
1130
+ uuid?: string;
1163
1131
  }
1164
1132
  export type XenApiRecord = XenApiSession | XenApiAuth | XenApiSubject | XenApiRole | XenApiTask | XenApiEvent | XenApiPool | XenApiPoolPatch | XenApiPoolUpdate | XenApiVm | XenApiVmMetrics | XenApiVmGuestMetrics | XenApiVmpp | XenApiVmss | XenApiVmAppliance | XenApiDrTask | XenApiHost | XenApiHostCrashdump | XenApiHostPatch | XenApiHostMetrics | XenApiHostCpu | XenApiNetwork | XenApiVif | XenApiVifMetrics | XenApiPif | XenApiPifMetrics | XenApiBond | XenApiVlan | XenApiSm | XenApiSr | XenApiSrStat | XenApiProbeResult | XenApiLvhd | XenApiVdi | XenApiVbd | XenApiVbdMetrics | XenApiPbd | XenApiCrashdump | XenApiVtpm | XenApiConsole | XenApiUser | XenApiDataSource | XenApiBlob | XenApiMessage | XenApiSecret | XenApiTunnel | XenApiNetworkSriov | XenApiPci | XenApiPgpu | XenApiGpuGroup | XenApiVgpu | XenApiVgpuType | XenApiPvsSite | XenApiPvsServer | XenApiPvsProxy | XenApiPvsCacheStorage | XenApiFeature | XenApiSdnController | XenApiVdiNbdServerInfo | XenApiPusb | XenApiUsbGroup | XenApiVusb | XenApiCluster | XenApiClusterHost | XenApiCertificate | XenApiRepository | XenApiObserver;
1133
+ export type WrappedXenApiRecord = XenApiHostWrapped | XenApiPoolWrapped | XenApiSrWrapped | XenApiVbdWrapped | XenApiVdiWrapped | XenApiVgpuWrapped | XenApiVifWrapped | XenApiVmWrapped | XenApiVtpmWrapped;
1134
+ export {};