4674 lines
179 KiB
TypeScript
4674 lines
179 KiB
TypeScript
/// <reference path="./libxml2-2.0.d.ts" />
|
|
/// <reference path="./gio-2.0.d.ts" />
|
|
/// <reference path="./gobject-2.0.d.ts" />
|
|
/// <reference path="./glib-2.0.d.ts" />
|
|
/// <reference path="./gmodule-2.0.d.ts" />
|
|
|
|
/**
|
|
* Type Definitions for Gjs (https://gjs.guide/)
|
|
*
|
|
* These type definitions are automatically generated, do not edit them by hand.
|
|
* If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
|
|
*
|
|
* The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
|
|
*/
|
|
|
|
declare module 'gi://Libosinfo?version=1.0' {
|
|
// Module dependencies
|
|
import type libxml2 from 'gi://libxml2?version=2.0';
|
|
import type Gio from 'gi://Gio?version=2.0';
|
|
import type GObject from 'gi://GObject?version=2.0';
|
|
import type GLib from 'gi://GLib?version=2.0';
|
|
import type GModule from 'gi://GModule?version=2.0';
|
|
|
|
export namespace Libosinfo {
|
|
/**
|
|
* Libosinfo-1.0
|
|
*/
|
|
|
|
export namespace DeviceDriverSigningReq {
|
|
export const $gtype: GObject.GType<DeviceDriverSigningReq>;
|
|
}
|
|
|
|
enum DeviceDriverSigningReq {
|
|
/**
|
|
* Script do not require device drivers
|
|
* to be signed.
|
|
*/
|
|
NONE,
|
|
/**
|
|
* Script must only be given signed
|
|
* device drivers. Some scripts will allow overriding this requirement through
|
|
* #osinfo_install_config_set_driver_signing function. You can query if a
|
|
* script supports this by checking if
|
|
* #OSINFO_INSTALL_CONFIG_PROP_DRIVER_SIGNING configuration parameter is used
|
|
* by the script in question (or other scripts in the same profile).
|
|
*/
|
|
STRICT,
|
|
/**
|
|
* A warning will be issued by OS
|
|
* installer if device drivers are not signed and most probably require user
|
|
* input (and thus breaking unattended installation). See
|
|
* #OSINFO_DEVICE_DRIVER_SIGNING_REQ_STRICT on how this warning can be disabled
|
|
* for some scripts.
|
|
*/
|
|
WARN,
|
|
}
|
|
/**
|
|
* #GError codes used for errors in #OSINFO_ERROR domain.
|
|
*/
|
|
class Error extends GLib.Error {
|
|
static $gtype: GObject.GType<Error>;
|
|
|
|
// Static fields
|
|
|
|
/**
|
|
* Generic Osinfo error;
|
|
*/
|
|
static GENERIC: number;
|
|
|
|
// Constructors
|
|
|
|
constructor(options: { message: string; code: number });
|
|
_init(...args: any[]): void;
|
|
|
|
// Static methods
|
|
|
|
/**
|
|
* Gets a #GQuark representing the string "libosinfo"
|
|
*/
|
|
static quark(): GLib.Quark;
|
|
}
|
|
|
|
/**
|
|
* Policy for configuration parameter presence
|
|
*/
|
|
|
|
/**
|
|
* Policy for configuration parameter presence
|
|
*/
|
|
export namespace InstallConfigParamPolicy {
|
|
export const $gtype: GObject.GType<InstallConfigParamPolicy>;
|
|
}
|
|
|
|
enum InstallConfigParamPolicy {
|
|
/**
|
|
* no policy defined
|
|
*/
|
|
NONE,
|
|
/**
|
|
* config parameter is required
|
|
*/
|
|
REQUIRED,
|
|
/**
|
|
* config parameter may be omitted
|
|
*/
|
|
OPTIONAL,
|
|
}
|
|
|
|
export namespace InstallScriptInstallationSource {
|
|
export const $gtype: GObject.GType<InstallScriptInstallationSource>;
|
|
}
|
|
|
|
enum InstallScriptInstallationSource {
|
|
/**
|
|
* A media will be used as
|
|
* the installation source.
|
|
*/
|
|
MEDIA,
|
|
/**
|
|
* A network method will
|
|
* be used as installation source.
|
|
*/
|
|
NETWORK,
|
|
}
|
|
/**
|
|
* #GError codes used for errors in the #OSINFO_MEDIA_ERROR domain, during
|
|
* reading of data from install media location.
|
|
*/
|
|
class MediaError extends GLib.Error {
|
|
static $gtype: GObject.GType<MediaError>;
|
|
|
|
// Static fields
|
|
|
|
/**
|
|
* No descriptors.
|
|
*/
|
|
static NO_DESCRIPTORS: number;
|
|
/**
|
|
* No Primary volume descriptor.
|
|
*/
|
|
static NO_PVD: number;
|
|
/**
|
|
* No supplementary volume descriptor.
|
|
*/
|
|
static NO_SVD: number;
|
|
/**
|
|
* Not enough metadata.
|
|
*/
|
|
static INSUFFICIENT_METADATA: number;
|
|
/**
|
|
* Install media not bootable.
|
|
*/
|
|
static NOT_BOOTABLE: number;
|
|
/**
|
|
* No directory record extent
|
|
* found.
|
|
*/
|
|
static NO_DIRECTORY_RECORD_EXTENT: number;
|
|
|
|
// Constructors
|
|
|
|
constructor(options: { message: string; code: number });
|
|
_init(...args: any[]): void;
|
|
|
|
// Static methods
|
|
|
|
static quark(): GLib.Quark;
|
|
}
|
|
|
|
export namespace PathFormat {
|
|
export const $gtype: GObject.GType<PathFormat>;
|
|
}
|
|
|
|
enum PathFormat {
|
|
/**
|
|
* Unix/Linux path format, e.g /home/foo/bar.txt
|
|
*/
|
|
UNIX,
|
|
/**
|
|
* DOS/Windows path format, e.g \My Documents\bar.txt
|
|
*/
|
|
DOS,
|
|
}
|
|
/**
|
|
* Enum values used to form relationships between products
|
|
*/
|
|
|
|
/**
|
|
* Enum values used to form relationships between products
|
|
*/
|
|
export namespace ProductRelationship {
|
|
export const $gtype: GObject.GType<ProductRelationship>;
|
|
}
|
|
|
|
enum ProductRelationship {
|
|
/**
|
|
* a descendent (RHEL-5 derives from Fedora-6)
|
|
*/
|
|
DERIVES_FROM,
|
|
/**
|
|
* a new version release (RHEL-6 upgrades RHEL-4)
|
|
*/
|
|
UPGRADES,
|
|
/**
|
|
* a perfect clone (CentOS-5 clones RHEL-5)
|
|
*/
|
|
CLONES,
|
|
}
|
|
|
|
export namespace ReleaseStatus {
|
|
export const $gtype: GObject.GType<ReleaseStatus>;
|
|
}
|
|
|
|
enum ReleaseStatus {
|
|
/**
|
|
* A released OS. (Since: 0.2.9)
|
|
*/
|
|
RELEASED,
|
|
/**
|
|
* A continuous integration snapshot and not
|
|
* an actual released product yet. For example, gnome-continuous images for
|
|
* development snapshots of GNOME and nightly build ISOs of Fedora etc.
|
|
* (Since: 0.2.9)
|
|
*/
|
|
SNAPSHOT,
|
|
/**
|
|
* A pre-release. For example, alpha and
|
|
* beta pre-releases of Fedora etc. (Since: 0.2.9)
|
|
*/
|
|
PRERELEASE,
|
|
/**
|
|
* A rolling version of an OS and thus with no
|
|
* actual releases. For example, Gentoo, Arch Linux, etc. (Since: 1.4.0)
|
|
*/
|
|
ROLLING,
|
|
}
|
|
/**
|
|
* #GError codes used for errors in the #OSINFO_TREE_ERROR domain, during
|
|
* reading the treeinfo from a URI.
|
|
*/
|
|
class TreeError extends GLib.Error {
|
|
static $gtype: GObject.GType<TreeError>;
|
|
|
|
// Static fields
|
|
|
|
/**
|
|
* No treeinfo found;
|
|
*/
|
|
static NO_TREEINFO: number;
|
|
/**
|
|
* The URL protocol is not supported.
|
|
*/
|
|
static NOT_SUPPORTED_PROTOCOL: number;
|
|
|
|
// Constructors
|
|
|
|
constructor(options: { message: string; code: number });
|
|
_init(...args: any[]): void;
|
|
|
|
// Static methods
|
|
|
|
/**
|
|
* Gets a #GQuark representing the string "osinfo-tree-error"
|
|
*/
|
|
static quark(): GLib.Quark;
|
|
}
|
|
|
|
const ARCHITECTURE_ALL: string;
|
|
const AVATAR_FORMAT_PROP_ALPHA: string;
|
|
const AVATAR_FORMAT_PROP_HEIGHT: string;
|
|
const AVATAR_FORMAT_PROP_MIME_TYPE: string;
|
|
const AVATAR_FORMAT_PROP_WIDTH: string;
|
|
const DEVICELINK_PROP_DRIVER: string;
|
|
const DEVICELINK_PROP_SUPPORTED: string;
|
|
const DEVICE_DRIVER_DEFAULT_PRIORITY: number;
|
|
const DEVICE_DRIVER_PROP_ARCHITECTURE: string;
|
|
const DEVICE_DRIVER_PROP_DEVICE: string;
|
|
const DEVICE_DRIVER_PROP_FILE: string;
|
|
const DEVICE_DRIVER_PROP_LOCATION: string;
|
|
const DEVICE_DRIVER_PROP_PRE_INSTALLABLE: string;
|
|
const DEVICE_DRIVER_PROP_PRIORITY: string;
|
|
const DEVICE_DRIVER_PROP_SIGNED: string;
|
|
const DEVICE_PROP_BUS_TYPE: string;
|
|
const DEVICE_PROP_CLASS: string;
|
|
const DEVICE_PROP_NAME: string;
|
|
const DEVICE_PROP_PRODUCT: string;
|
|
const DEVICE_PROP_PRODUCT_ID: string;
|
|
const DEVICE_PROP_SUBSYSTEM: string;
|
|
const DEVICE_PROP_VENDOR: string;
|
|
const DEVICE_PROP_VENDOR_ID: string;
|
|
const ENTITY_PROP_ID: string;
|
|
const FIRMWARE_PROP_ARCHITECTURE: string;
|
|
const FIRMWARE_PROP_SUPPORTED: string;
|
|
const FIRMWARE_PROP_TYPE: string;
|
|
const GIBIBYTES: number;
|
|
const IMAGE_PROP_ARCHITECTURE: string;
|
|
const IMAGE_PROP_CLOUD_INIT: string;
|
|
const IMAGE_PROP_FORMAT: string;
|
|
const IMAGE_PROP_URL: string;
|
|
const IMAGE_PROP_VARIANT: string;
|
|
const INSTALL_CONFIG_PARAM_PROP_DATAMAP: string;
|
|
const INSTALL_CONFIG_PARAM_PROP_NAME: string;
|
|
const INSTALL_CONFIG_PARAM_PROP_POLICY: string;
|
|
const INSTALL_CONFIG_PROP_ADMIN_PASSWORD: string;
|
|
const INSTALL_CONFIG_PROP_AVATAR_DISK: string;
|
|
const INSTALL_CONFIG_PROP_AVATAR_LOCATION: string;
|
|
const INSTALL_CONFIG_PROP_DRIVER_SIGNING: string;
|
|
const INSTALL_CONFIG_PROP_HARDWARE_ARCH: string;
|
|
const INSTALL_CONFIG_PROP_HOSTNAME: string;
|
|
const INSTALL_CONFIG_PROP_INSTALLATION_URL: string;
|
|
const INSTALL_CONFIG_PROP_L10N_KEYBOARD: string;
|
|
const INSTALL_CONFIG_PROP_L10N_LANGUAGE: string;
|
|
const INSTALL_CONFIG_PROP_L10N_TIMEZONE: string;
|
|
const INSTALL_CONFIG_PROP_POST_INSTALL_DRIVERS_DISK: string;
|
|
const INSTALL_CONFIG_PROP_POST_INSTALL_DRIVERS_LOCATION: string;
|
|
const INSTALL_CONFIG_PROP_PRE_INSTALL_DRIVERS_DISK: string;
|
|
const INSTALL_CONFIG_PROP_PRE_INSTALL_DRIVERS_LOCATION: string;
|
|
const INSTALL_CONFIG_PROP_REG_LOGIN: string;
|
|
const INSTALL_CONFIG_PROP_REG_PASSWORD: string;
|
|
const INSTALL_CONFIG_PROP_REG_PRODUCTKEY: string;
|
|
const INSTALL_CONFIG_PROP_SCRIPT_DISK: string;
|
|
const INSTALL_CONFIG_PROP_TARGET_DISK: string;
|
|
const INSTALL_CONFIG_PROP_USER_ADMIN: string;
|
|
const INSTALL_CONFIG_PROP_USER_AUTOLOGIN: string;
|
|
const INSTALL_CONFIG_PROP_USER_LOGIN: string;
|
|
const INSTALL_CONFIG_PROP_USER_PASSWORD: string;
|
|
const INSTALL_CONFIG_PROP_USER_REALNAME: string;
|
|
const INSTALL_SCRIPT_PROFILE_DESKTOP: string;
|
|
const INSTALL_SCRIPT_PROFILE_JEOS: string;
|
|
const INSTALL_SCRIPT_PROP_CAN_POST_INSTALL_DRIVERS: string;
|
|
const INSTALL_SCRIPT_PROP_CAN_PRE_INSTALL_DRIVERS: string;
|
|
const INSTALL_SCRIPT_PROP_EXPECTED_FILENAME: string;
|
|
const INSTALL_SCRIPT_PROP_INJECTION_METHOD: string;
|
|
const INSTALL_SCRIPT_PROP_INSTALLATION_SOURCE: string;
|
|
const INSTALL_SCRIPT_PROP_NEEDS_INTERNET: string;
|
|
const INSTALL_SCRIPT_PROP_PATH_FORMAT: string;
|
|
const INSTALL_SCRIPT_PROP_POST_INSTALL_DRIVERS_SIGNING_REQ: string;
|
|
const INSTALL_SCRIPT_PROP_PREFERRED_INJECTION_METHOD: string;
|
|
const INSTALL_SCRIPT_PROP_PRE_INSTALL_DRIVERS_SIGNING_REQ: string;
|
|
const INSTALL_SCRIPT_PROP_PRODUCT_KEY_FORMAT: string;
|
|
const INSTALL_SCRIPT_PROP_PROFILE: string;
|
|
const INSTALL_SCRIPT_PROP_TEMPLATE_DATA: string;
|
|
const INSTALL_SCRIPT_PROP_TEMPLATE_URI: string;
|
|
const KIBIBYTES: number;
|
|
/**
|
|
* libosinfo major version number.
|
|
*/
|
|
const MAJOR_VERSION: number;
|
|
const MEBIBYTES: number;
|
|
const MEDIA_PROP_APPLICATION_ID: string;
|
|
const MEDIA_PROP_ARCHITECTURE: string;
|
|
const MEDIA_PROP_BOOTABLE: string;
|
|
const MEDIA_PROP_EJECT_AFTER_INSTALL: string;
|
|
const MEDIA_PROP_INITRD: string;
|
|
const MEDIA_PROP_INSTALLER: string;
|
|
const MEDIA_PROP_INSTALLER_REBOOTS: string;
|
|
const MEDIA_PROP_INSTALLER_SCRIPT: string;
|
|
const MEDIA_PROP_KERNEL: string;
|
|
const MEDIA_PROP_LANG: string;
|
|
const MEDIA_PROP_LANG_MAP: string;
|
|
const MEDIA_PROP_LANG_REGEX: string;
|
|
const MEDIA_PROP_LIVE: string;
|
|
const MEDIA_PROP_PUBLISHER_ID: string;
|
|
const MEDIA_PROP_SYSTEM_ID: string;
|
|
const MEDIA_PROP_URL: string;
|
|
const MEDIA_PROP_VARIANT: string;
|
|
const MEDIA_PROP_VOLUME_ID: string;
|
|
const MEDIA_PROP_VOLUME_SIZE: string;
|
|
const MEGAHERTZ: number;
|
|
/**
|
|
* libosinfo micro version number.
|
|
*/
|
|
const MICRO_VERSION: number;
|
|
/**
|
|
* libosinfo minor version number.
|
|
*/
|
|
const MINOR_VERSION: number;
|
|
const OS_PROP_CLOUD_IMAGE_USERNAME: string;
|
|
const OS_PROP_DISTRO: string;
|
|
const OS_PROP_FAMILY: string;
|
|
const OS_PROP_KERNEL_URL_ARGUMENT: string;
|
|
const OS_PROP_RELEASE_STATUS: string;
|
|
const OS_VARIANT_PROP_NAME: string;
|
|
const PRODUCT_PROP_CODENAME: string;
|
|
const PRODUCT_PROP_EOL_DATE: string;
|
|
const PRODUCT_PROP_LOGO: string;
|
|
const PRODUCT_PROP_NAME: string;
|
|
const PRODUCT_PROP_RELEASE_DATE: string;
|
|
const PRODUCT_PROP_SHORT_ID: string;
|
|
const PRODUCT_PROP_VENDOR: string;
|
|
const PRODUCT_PROP_VERSION: string;
|
|
const RESOURCES_PROP_ARCHITECTURE: string;
|
|
const RESOURCES_PROP_CPU: string;
|
|
const RESOURCES_PROP_N_CPUS: string;
|
|
const RESOURCES_PROP_RAM: string;
|
|
const RESOURCES_PROP_STORAGE: string;
|
|
const TREE_PROP_ARCHITECTURE: string;
|
|
const TREE_PROP_BOOT_ISO: string;
|
|
const TREE_PROP_HAS_TREEINFO: string;
|
|
const TREE_PROP_INITRD: string;
|
|
const TREE_PROP_KERNEL: string;
|
|
const TREE_PROP_TREEINFO_ARCH: string;
|
|
const TREE_PROP_TREEINFO_FAMILY: string;
|
|
const TREE_PROP_TREEINFO_VARIANT: string;
|
|
const TREE_PROP_TREEINFO_VERSION: string;
|
|
const TREE_PROP_URL: string;
|
|
const TREE_PROP_VARIANT: string;
|
|
/**
|
|
* Gets a #GQuark representing the string "libosinfo"
|
|
* @returns the #GQuark representing the string.
|
|
*/
|
|
function error_quark(): GLib.Quark;
|
|
function media_error_quark(): GLib.Quark;
|
|
/**
|
|
* Gets a #GQuark representing the string "osinfo-tree-error"
|
|
* @returns the #GQuark representing the string.
|
|
*/
|
|
function tree_error_quark(): GLib.Quark;
|
|
|
|
export namespace InstallScriptInjectionMethod {
|
|
export const $gtype: GObject.GType<InstallScriptInjectionMethod>;
|
|
}
|
|
|
|
enum InstallScriptInjectionMethod {
|
|
/**
|
|
* Support injection of the
|
|
* installation script through a CD-ROM.
|
|
*/
|
|
CDROM,
|
|
/**
|
|
* Support injection of the
|
|
* installation script through a disk.
|
|
*/
|
|
DISK,
|
|
/**
|
|
* Support injection of the
|
|
* installation script through a floppy disk.
|
|
*/
|
|
FLOPPY,
|
|
/**
|
|
* Support injection of the
|
|
* installation script through the initrd.
|
|
*/
|
|
INITRD,
|
|
/**
|
|
* Support injection of the
|
|
* installation script from the web.
|
|
*/
|
|
WEB,
|
|
}
|
|
/**
|
|
* OSINFO_MEDIA_DETECT_REQUIRE_BOOTABLE: Requires a media to be bootable.
|
|
* Flags used for detecting a media.
|
|
*/
|
|
|
|
/**
|
|
* OSINFO_MEDIA_DETECT_REQUIRE_BOOTABLE: Requires a media to be bootable.
|
|
* Flags used for detecting a media.
|
|
*/
|
|
export namespace MediaDetectFlags {
|
|
export const $gtype: GObject.GType<MediaDetectFlags>;
|
|
}
|
|
|
|
enum MediaDetectFlags {
|
|
BOOTABLE,
|
|
}
|
|
module AvatarFormat {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
alpha: boolean;
|
|
height: number;
|
|
mime_types: string[];
|
|
mimeTypes: string[];
|
|
width: number;
|
|
}
|
|
}
|
|
|
|
class AvatarFormat extends Entity {
|
|
static $gtype: GObject.GType<AvatarFormat>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* Whether alpha channel is supported in the avatar.
|
|
*/
|
|
get alpha(): boolean;
|
|
/**
|
|
* The required height (in pixels) of the avatar.
|
|
*/
|
|
get height(): number;
|
|
/**
|
|
* The allowed mime-types for the avatar.
|
|
*/
|
|
get mime_types(): string[];
|
|
/**
|
|
* The allowed mime-types for the avatar.
|
|
*/
|
|
get mimeTypes(): string[];
|
|
/**
|
|
* The required width (in pixels) of the avatar.
|
|
*/
|
|
get width(): number;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<AvatarFormat.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): AvatarFormat;
|
|
|
|
// Methods
|
|
|
|
get_alpha(): boolean;
|
|
get_height(): number;
|
|
get_mime_types(): string[];
|
|
get_width(): number;
|
|
}
|
|
|
|
module Datamap {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {}
|
|
}
|
|
|
|
class Datamap extends Entity {
|
|
static $gtype: GObject.GType<Datamap>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Datamap.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string): Datamap;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Adds the input value and the output value associated to it to
|
|
* the `map`.
|
|
* @param inval the input value
|
|
* @param outval the output value
|
|
*/
|
|
insert(inval: string, outval: string): void;
|
|
/**
|
|
* Returns the output value with which `inval` is associated to.
|
|
* @param inval the input value
|
|
*/
|
|
lookup(inval: string): string;
|
|
/**
|
|
* Returns the input value with which `outval` is associated to.
|
|
* @param outval the output value
|
|
*/
|
|
reverse_lookup(outval: string): string;
|
|
}
|
|
|
|
module DatamapList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class DatamapList extends List {
|
|
static $gtype: GObject.GType<DatamapList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<DatamapList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): DatamapList;
|
|
}
|
|
|
|
module Db {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {}
|
|
}
|
|
|
|
class Db extends GObject.Object {
|
|
static $gtype: GObject.GType<Db>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Db.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): Db;
|
|
|
|
// Methods
|
|
|
|
add_datamap(datamap: Datamap): void;
|
|
add_deployment(deployment: Deployment): void;
|
|
add_device(device: Device): void;
|
|
add_install_script(script: InstallScript): void;
|
|
add_os(os: Os): void;
|
|
add_platform(platform: Platform): void;
|
|
/**
|
|
* Find the deployment for `os` on `platform,` if any.
|
|
* @param os the operating system to find
|
|
* @param platform the virtualization platform
|
|
* @returns the deployment, or NULL
|
|
*/
|
|
find_deployment(os: Os, platform: Platform): Deployment;
|
|
get_datamap(id: string): Datamap;
|
|
get_datamap_list(): DatamapList;
|
|
get_deployment(id: string): Deployment;
|
|
get_deployment_list(): DeploymentList;
|
|
get_device(id: string): Device;
|
|
get_device_list(): DeviceList;
|
|
get_install_script(id: string): InstallScript;
|
|
get_install_script_list(): InstallScriptList;
|
|
get_os(id: string): Os;
|
|
get_os_list(): OsList;
|
|
get_platform(id: string): Platform;
|
|
get_platform_list(): PlatformList;
|
|
/**
|
|
* Guess operating system given an #OsinfoMedia object.
|
|
* @param media the installation media
|
|
* @returns the operating system, or NULL if guessing failed
|
|
*/
|
|
guess_os_from_media(media: Media): [Os, Media | null];
|
|
/**
|
|
* Guess operating system given an #OsinfoTree object.
|
|
* @param tree the installation tree
|
|
* @returns the operating system, or NULL if guessing failed
|
|
*/
|
|
guess_os_from_tree(tree: Tree): [Os, Tree | null];
|
|
/**
|
|
* Try to match a newly created `media` with a media description from `db`.
|
|
* If found, `media` will be filled with the corresponding information
|
|
* stored in `db`. In particular, after a call to osinfo_db_identify_media(), if
|
|
* the media could be identified, its OsinfoEntify::id and OsinfoMedia::os
|
|
* properties will be set.
|
|
*
|
|
* The match for `media` in `db` is not guaranteed to be unique and
|
|
* this method will only return the first match found. The order
|
|
* in which matches are identified is not guaranteed, so when there
|
|
* are multiple matches, the returned match may vary over time.
|
|
* Applications are recommended to use the #osinfo_db_identify_all_media
|
|
* method instead to receive all matched media.
|
|
* @param media the installation media data
|
|
* @returns TRUE if @media was found in @db, FALSE otherwise
|
|
*/
|
|
identify_media(media: Media): boolean;
|
|
/**
|
|
* Try to match a newly created `media` with a media description from `db`.
|
|
* The return list will contain any #OsinfoMedia instances from `db` that
|
|
* matched `media`. Usuaully there will only be one match returned, but
|
|
* applications should be prepared to deal with multiple matches. The
|
|
* returned #OsinfoMedia instances will have their OsinfoEntify::id and
|
|
* OsinfoMedia::os properties will be set, while `media` is left unmodified.
|
|
* @param media the installation media data
|
|
* @returns a list containing any matches for @media found in @db
|
|
*/
|
|
identify_medialist(media: Media): MediaList;
|
|
/**
|
|
* Try to match a newly created `tree` with a tree description from `db`.
|
|
* If found, `tree` will be filled with the corresponding information
|
|
* stored in `db`. In particular, after a call to osinfo_db_identify_tree(), if
|
|
* the tree could be identified, its OsinfoEntify::id and OsinfoMedia::os
|
|
* properties will be set.
|
|
*
|
|
* The match for `tree` in `db` is not guaranteed to be unique and
|
|
* this method will only return the first match found. The order
|
|
* in which matches are identified is not guaranteed, so when there
|
|
* are multiple matches, the returned match may vary over time.
|
|
* Applications are recommended to use the #osinfo_db_identify_all_tree
|
|
* method instead to receive all matched tree.
|
|
* @param tree the installation tree data
|
|
* @returns TRUE if @tree was found in @db, FALSE otherwise
|
|
*/
|
|
identify_tree(tree: Tree): boolean;
|
|
/**
|
|
* Try to match a newly created `tree` with a tree description from `db`.
|
|
* The return list will contain any #OsinfoTree instances from `db` that
|
|
* matched `tree`. Usuaully there will only be one match returned, but
|
|
* applications should be prepared to deal with multiple matches. The
|
|
* returned #OsinfoTree instances will have their OsinfoEntify::id and
|
|
* OsinfoTree::os properties will be set, while `tree` is left unmodified.
|
|
* @param tree the installation tree data
|
|
* @returns a list containing any matches for @tree found in @db
|
|
*/
|
|
identify_treelist(tree: Tree): TreeList;
|
|
/**
|
|
* Get all operating systems that are the referee
|
|
* in an operating system relationship.
|
|
* @param relshp the product relationship
|
|
* @returns a list of operating systems
|
|
*/
|
|
unique_values_for_os_relationship(relshp: ProductRelationship | null): OsList;
|
|
/**
|
|
* Get all platforms that are the referee
|
|
* in an platform relationship.
|
|
* @param relshp the product relationship
|
|
* @returns a list of virtualization platforms
|
|
*/
|
|
unique_values_for_platform_relationship(relshp: ProductRelationship | null): PlatformList;
|
|
/**
|
|
* Get all unique values for a named property amongst all
|
|
* deployments in the database
|
|
* @param propName a property name
|
|
* @returns a list of strings
|
|
*/
|
|
unique_values_for_property_in_deployment(propName: string): string[];
|
|
/**
|
|
* Get all unique values for a named property amongst all
|
|
* devices in the database
|
|
* @param propName a property name
|
|
* @returns a list of strings
|
|
*/
|
|
unique_values_for_property_in_device(propName: string): string[];
|
|
/**
|
|
* Get all unique values for a named property amongst all
|
|
* operating systems in the database
|
|
* @param propName a property name
|
|
* @returns a list of strings
|
|
*/
|
|
unique_values_for_property_in_os(propName: string): string[];
|
|
/**
|
|
* Get all unique values for a named property amongst all
|
|
* platforms in the database
|
|
* @param propName a property name
|
|
* @returns a list of strings
|
|
*/
|
|
unique_values_for_property_in_platform(propName: string): string[];
|
|
}
|
|
|
|
module Deployment {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
os: Os;
|
|
platform: Platform;
|
|
}
|
|
}
|
|
|
|
class Deployment extends Entity {
|
|
static $gtype: GObject.GType<Deployment>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The operating system to be deployed
|
|
*/
|
|
get os(): Os;
|
|
/**
|
|
* The platform to deploy on
|
|
*/
|
|
get platform(): Platform;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Deployment.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string, os: Os, platform: Platform): Deployment;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Associate a device with a deployment. The returned #OsinfoDeviceLink
|
|
* can be used to record extra metadata against the link
|
|
* @param dev the device to associate
|
|
* @returns the device association
|
|
*/
|
|
add_device(dev: Device): DeviceLink;
|
|
/**
|
|
* Retrieve all the associated devices matching the filter.
|
|
* The filter matches against the link, not the device.
|
|
* @param filter an optional filter
|
|
* @returns a list of #OsinfoDevice entities
|
|
*/
|
|
get_device_links(filter?: Filter | null): DeviceLinkList;
|
|
/**
|
|
* Retrieve all the associated devices matching the filter.
|
|
* The filter matches against the device, not the link.
|
|
* @param filter an optional filter
|
|
* @returns a list of #OsinfoDevice entities
|
|
*/
|
|
get_devices(filter?: Filter | null): DeviceList;
|
|
/**
|
|
* Get the operating system for the deployment
|
|
* @returns an OS, or NULL
|
|
*/
|
|
get_os(): Os;
|
|
/**
|
|
* Get the platform for the deployment
|
|
* @returns a platform, or NULL
|
|
*/
|
|
get_platform(): Platform;
|
|
/**
|
|
* Get the preferred device matching a given filter
|
|
* @param filter a device metadata filter
|
|
* @returns a device, or NULL
|
|
*/
|
|
get_preferred_device(filter?: Filter | null): Device;
|
|
/**
|
|
* Get the preferred device link matching a given filter and platform.
|
|
* The filter matches against attributes on the link, not the device.
|
|
* @param filter a device metadata filter
|
|
* @returns a device, or NULL
|
|
*/
|
|
get_preferred_device_link(filter?: Filter | null): DeviceLink;
|
|
}
|
|
|
|
module DeploymentList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class DeploymentList extends List {
|
|
static $gtype: GObject.GType<DeploymentList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<DeploymentList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): DeploymentList;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Construct a new deployment list that is filled with deployments
|
|
* from `source`
|
|
* @returns a copy of the deployment list
|
|
*/
|
|
new_copy(): DeploymentList;
|
|
/**
|
|
* Construct a new deployment list that is filled with deployments
|
|
* from `source` that match `filter`
|
|
* @param filter the filter to apply
|
|
* @returns a filtered copy of the deployment list
|
|
*/
|
|
new_filtered(filter: Filter): DeploymentList;
|
|
/**
|
|
* Construct a new deployment list that is filled with only the
|
|
* deployments that are present in both `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second deployment list to copy
|
|
* @returns an intersection of the two deployment lists
|
|
*/
|
|
new_intersection(sourceTwo: DeploymentList): DeploymentList;
|
|
/**
|
|
* Construct a new deployment list that is filled with all the
|
|
* deployments that are present in either `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second deployment list to copy
|
|
* @returns a union of the two deployment lists
|
|
*/
|
|
new_union(sourceTwo: DeploymentList): DeploymentList;
|
|
}
|
|
|
|
module Device {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {}
|
|
}
|
|
|
|
class Device extends Entity {
|
|
static $gtype: GObject.GType<Device>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Device.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string): Device;
|
|
|
|
// Methods
|
|
|
|
get_bus_type(): string;
|
|
get_class(): string;
|
|
get_name(): string;
|
|
get_product(): string;
|
|
get_product_id(): string;
|
|
get_subsystem(): string;
|
|
get_vendor(): string;
|
|
get_vendor_id(): string;
|
|
}
|
|
|
|
module DeviceDriver {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {}
|
|
}
|
|
|
|
class DeviceDriver extends Entity {
|
|
static $gtype: GObject.GType<DeviceDriver>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<DeviceDriver.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Retrieves the target hardware architecture of `driver`.
|
|
* @returns the hardware architecture.
|
|
*/
|
|
get_architecture(): string;
|
|
get_devices(): DeviceList;
|
|
/**
|
|
* Retrieves the names of driver files under the location returned by
|
|
* #osinfo_device_driver_get_location.
|
|
* @returns The list of driver files.
|
|
*/
|
|
get_files(): string[];
|
|
/**
|
|
* Retrieves the location of the `driver` as a URL.
|
|
* @returns the location of the driver.
|
|
*/
|
|
get_location(): string;
|
|
get_pre_installable(): boolean;
|
|
/**
|
|
* Returns the priority of the device driver. The higher the value, the more
|
|
* important it is.
|
|
* @returns the priority of the device driver.
|
|
*/
|
|
get_priority(): number;
|
|
/**
|
|
* Some OS vendors recommend or require device drivers to be signed by them
|
|
* before these device drivers could be installed on their OS.
|
|
* @returns TRUE if @driver is signed, FALSE otherwise.
|
|
*/
|
|
get_signed(): boolean;
|
|
}
|
|
|
|
module DeviceDriverList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class DeviceDriverList extends List {
|
|
static $gtype: GObject.GType<DeviceDriverList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<DeviceDriverList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): DeviceDriverList;
|
|
}
|
|
|
|
module DeviceLink {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
target: Device;
|
|
}
|
|
}
|
|
|
|
class DeviceLink extends Entity {
|
|
static $gtype: GObject.GType<DeviceLink>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The target of the device link.
|
|
*/
|
|
get target(): Device;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<DeviceLink.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](target: Device): DeviceLink;
|
|
|
|
// Methods
|
|
|
|
get_driver(): string;
|
|
/**
|
|
* Retrieve the #OsinfoDevice that the link points to.
|
|
* @returns the target of the device link
|
|
*/
|
|
get_target(): Device;
|
|
}
|
|
|
|
module DeviceLinkFilter {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Filter.ConstructorProps {
|
|
target_filter: Filter;
|
|
targetFilter: Filter;
|
|
}
|
|
}
|
|
|
|
class DeviceLinkFilter extends Filter {
|
|
static $gtype: GObject.GType<DeviceLinkFilter>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The operating system to be deployed
|
|
*/
|
|
get target_filter(): Filter;
|
|
/**
|
|
* The operating system to be deployed
|
|
*/
|
|
get targetFilter(): Filter;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<DeviceLinkFilter.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](filter: Filter): DeviceLinkFilter;
|
|
// Conflicted with Libosinfo.Filter.new
|
|
|
|
static ['new'](...args: never[]): any;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Retrieve the filter used to match against the target of
|
|
* the device link
|
|
* @returns the target filter object
|
|
*/
|
|
get_target_filter(): Filter;
|
|
}
|
|
|
|
module DeviceLinkList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class DeviceLinkList extends List {
|
|
static $gtype: GObject.GType<DeviceLinkList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<DeviceLinkList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): DeviceLinkList;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Get all devices matching a given filter
|
|
* @param filter an optional device property filter
|
|
* @returns A list of devices
|
|
*/
|
|
get_devices(filter?: Filter | null): DeviceList;
|
|
/**
|
|
* Construct a new devicelink list that is filled with devicelinks
|
|
* from `source`
|
|
* @returns a copy of the devicelink list
|
|
*/
|
|
new_copy(): DeviceLinkList;
|
|
/**
|
|
* Construct a new devicelink list that is filled with devicelinks
|
|
* from `source` that match `filter`
|
|
* @param filter the filter to apply
|
|
* @returns a filtered copy of the devicelink list
|
|
*/
|
|
new_filtered(filter: Filter): DeviceLinkList;
|
|
/**
|
|
* Construct a new devicelink list that is filled with only the
|
|
* devicelinks that are present in both `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second devicelink list to copy
|
|
* @returns an intersection of the two devicelink lists
|
|
*/
|
|
new_intersection(sourceTwo: DeviceLinkList): DeviceLinkList;
|
|
/**
|
|
* Construct a new devicelink list that is filled with all the
|
|
* devicelinks that are present in either `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second devicelink list to copy
|
|
* @returns a union of the two devicelink lists
|
|
*/
|
|
new_union(sourceTwo: DeviceLinkList): DeviceLinkList;
|
|
}
|
|
|
|
module DeviceList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class DeviceList extends List {
|
|
static $gtype: GObject.GType<DeviceList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<DeviceList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): DeviceList;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Construct a new device list that is filled with devices
|
|
* from `source`
|
|
* @returns a copy of the device list
|
|
*/
|
|
new_copy(): DeviceList;
|
|
/**
|
|
* Construct a new device list that is filled with devices
|
|
* from `source` that match `filter`
|
|
* @param filter the filter to apply
|
|
* @returns a filtered copy of the device list
|
|
*/
|
|
new_filtered(filter: Filter): DeviceList;
|
|
/**
|
|
* Construct a new device list that is filled with only the
|
|
* devices that are present in both `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second device list to copy
|
|
* @returns an intersection of the two device lists
|
|
*/
|
|
new_intersection(sourceTwo: DeviceList): DeviceList;
|
|
/**
|
|
* Construct a new device list that is filled with all the
|
|
* devices that are present in either `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second device list to copy
|
|
* @returns a union of the two device lists
|
|
*/
|
|
new_union(sourceTwo: DeviceList): DeviceList;
|
|
}
|
|
|
|
module Entity {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
id: string;
|
|
}
|
|
}
|
|
|
|
abstract class Entity extends GObject.Object {
|
|
static $gtype: GObject.GType<Entity>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The unique identifier for the entity The format of identifiers
|
|
* is undefined, but the recommended practice is to use a URI.
|
|
* This parameter must be set at time of construction as no
|
|
* default value is provided.
|
|
*/
|
|
get id(): string;
|
|
set id(val: string);
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Entity.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Adds a new parameter against the entity. A key can have multiple
|
|
* values associated. Thus repeated calls with the same key will
|
|
* build up a list of possible values.
|
|
* @param key the name of the key
|
|
* @param value the data to associated with that key
|
|
*/
|
|
add_param(key: string, value: string): void;
|
|
/**
|
|
* Remove all values associated with a key
|
|
* @param key the name of the key
|
|
*/
|
|
clear_param(key: string): void;
|
|
/**
|
|
* Retrieves the unique key for the entity. The format of identifiers
|
|
* is undefined, but the recommended practice is to use a URI.
|
|
* @returns the unique key for the entity
|
|
*/
|
|
get_id(): string;
|
|
/**
|
|
* Retrieve all the known parameter keys associated with
|
|
* the entity
|
|
* @returns The list of string parameters
|
|
*/
|
|
get_param_keys(): string[];
|
|
/**
|
|
* Retrieve the parameter value associated with a named key. If
|
|
* multiple values are stored against the key, only the first
|
|
* value is returned. If no value is associated, NULL is returned
|
|
* @param key the name of the key
|
|
* @returns the value associated with the key, or NULL
|
|
*/
|
|
get_param_value(key: string): string;
|
|
/**
|
|
* Retrieve the parameter value associated with a named key as a
|
|
* boolean. If multiple values are stored against the key, only the
|
|
* first value is returned. If no value is associated, FALSE is returned
|
|
* @param key the name of the key
|
|
* @returns the value associated with the key as a boolean, or FALSE
|
|
*/
|
|
get_param_value_boolean(key: string): boolean;
|
|
/**
|
|
* Retrieve the parameter value associated with a named key as a
|
|
* boolean. If multiple values are stored against the key, only the
|
|
* first value is returned. If no value is associated, `default_value`
|
|
* is returned.
|
|
* @param key the name of the key
|
|
* @param default_value the value to be returned in case there's no value associated with the @key
|
|
* @returns the value associated with the key as a boolean, or @default_value
|
|
*/
|
|
get_param_value_boolean_with_default(key: string, default_value: boolean): boolean;
|
|
/**
|
|
* Retrieve the parameter value associated with a named key as an
|
|
* enum value. If multiple values are stored against the key, only
|
|
* the first value is returned. If no value is associated, the
|
|
* `default_value` is returned.
|
|
* @param key the name of the key
|
|
* @param enum_type the enum type
|
|
* @param default_value the default value to be used, in case there's no value associated with the key
|
|
* @returns the enum value associated with the key, or @default_value.
|
|
*/
|
|
get_param_value_enum(key: string, enum_type: GObject.GType, default_value: number): number;
|
|
/**
|
|
* Retrieve the parameter value associated with a named key as an
|
|
* int64. If multiple values are stored against the key, only the
|
|
* first value is returned. If no value is associated, -1 is returned.
|
|
* @param key the name of the key
|
|
* @returns the value associated with the key as an int64, or -1.
|
|
*/
|
|
get_param_value_int64(key: string): number;
|
|
/**
|
|
* Retrieve the parameter value associated with a named key as an
|
|
* int64. If multiple values are stored against the key, only the
|
|
* first value is returned. If no value is associated, `default_value`
|
|
* is returned.
|
|
* @param key the name of the key
|
|
* @param default_value the value to be returned in case there's no value associated with the @key
|
|
* @returns the value associated with the key as an int64, or @default_value
|
|
*/
|
|
get_param_value_int64_with_default(key: string, default_value: number): number;
|
|
/**
|
|
* Retrieve all the parameter values associated with a named
|
|
* key. If no values are associated, NULL is returned
|
|
* @param key the name of the key
|
|
* @returns the values associated with the key
|
|
*/
|
|
get_param_value_list(key: string): string[];
|
|
/**
|
|
* Sets a new parameter against the entity. If the key already
|
|
* has a value associated with it, the existing value will be
|
|
* cleared.
|
|
* @param key the name of the key
|
|
* @param value the data to associated with that key
|
|
*/
|
|
set_param(key: string, value: string): void;
|
|
/**
|
|
* Sets a new parameter against the entity. If the key already
|
|
* has a value associated with it, the existing value will be
|
|
* cleared.
|
|
* @param key the name of the key
|
|
* @param value the boolean value to be associated with that key
|
|
*/
|
|
set_param_boolean(key: string, value: boolean): void;
|
|
/**
|
|
* Sets a new parameter against the entity. If the key already
|
|
* has a value associated with it, the existing value will be
|
|
* cleared.
|
|
* @param key the name of the key
|
|
* @param value the enum value to be associated with that key
|
|
* @param enum_type the enum type
|
|
*/
|
|
set_param_enum(key: string, value: number, enum_type: GObject.GType): void;
|
|
/**
|
|
* Sets a new parameter against the entity. If the key already
|
|
* has a value associated with it, the existing value will be
|
|
* cleared.
|
|
* @param key the name of the key
|
|
* @param value the int64 value to be associated with that key
|
|
*/
|
|
set_param_int64(key: string, value: number): void;
|
|
}
|
|
|
|
module Filter {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {}
|
|
}
|
|
|
|
class Filter extends GObject.Object {
|
|
static $gtype: GObject.GType<Filter>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Filter.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): Filter;
|
|
|
|
// Virtual methods
|
|
|
|
/**
|
|
* Determine of an entity matches a filter
|
|
* @param entity an entity to query
|
|
*/
|
|
vfunc_matches(entity: Entity): boolean;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Adds a constraint that requires the entity to have
|
|
* a property key `propName` with a value of `propVal`.
|
|
* If multiple constraints are added for the same
|
|
* `propName,` with different values, the entity have
|
|
* all property values.
|
|
* @param propName the name of the parameter key
|
|
* @param propVal the required property value
|
|
*/
|
|
add_constraint(propName: string, propVal: string): void;
|
|
/**
|
|
* Remove all filter constraints for the matching property
|
|
* name.
|
|
* @param propName name of the key to remove constraints for
|
|
*/
|
|
clear_constraint(propName: string): void;
|
|
/**
|
|
* Remove all filter property constraints
|
|
*/
|
|
clear_constraints(): void;
|
|
/**
|
|
* Get a list of all constraint property keys
|
|
* @returns List of constraint keys
|
|
*/
|
|
get_constraint_keys(): string[];
|
|
/**
|
|
* Get a list values for filter constraints with the named key
|
|
* @param propName the name of the key
|
|
* @returns List of constraint values
|
|
*/
|
|
get_constraint_values(propName: string): string[];
|
|
/**
|
|
* Determine of an entity matches a filter
|
|
* @param entity an entity to query
|
|
* @returns TRUE if entity passes the filter, FALSE otherwise
|
|
*/
|
|
matches(entity: Entity): boolean;
|
|
}
|
|
|
|
module Firmware {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
architecture: string;
|
|
type: string;
|
|
}
|
|
}
|
|
|
|
class Firmware extends Entity {
|
|
static $gtype: GObject.GType<Firmware>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The target hardware architecture of this firmware.
|
|
*/
|
|
get architecture(): string;
|
|
set architecture(val: string);
|
|
get type(): string;
|
|
set type(val: string);
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Firmware.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string, architecture: string, type: string): Firmware;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Retrieves the target hardware architecture of the OS `firmware` provides.
|
|
* @returns the hardware architecture, or NULL
|
|
*/
|
|
get_architecture(): string;
|
|
/**
|
|
* The type of the `firmware`
|
|
* @returns the type, or NULL
|
|
*/
|
|
get_firmware_type(): string;
|
|
/**
|
|
* Whether the `firmware` is supported or not
|
|
* @returns TRUE if supported, FALSE otherwise.
|
|
*/
|
|
is_supported(): boolean;
|
|
}
|
|
|
|
module FirmwareList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class FirmwareList extends List {
|
|
static $gtype: GObject.GType<FirmwareList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<FirmwareList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): FirmwareList;
|
|
}
|
|
|
|
module Image {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
architecture: string;
|
|
cloud_init: string;
|
|
cloudInit: string;
|
|
format: string;
|
|
url: string;
|
|
}
|
|
}
|
|
|
|
class Image extends Entity {
|
|
static $gtype: GObject.GType<Image>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The target hardware architecture of this image.
|
|
*/
|
|
get architecture(): string;
|
|
set architecture(val: string);
|
|
/**
|
|
* Whether the image supports cloud-init customizations or not.
|
|
*/
|
|
get cloud_init(): string;
|
|
set cloud_init(val: string);
|
|
/**
|
|
* Whether the image supports cloud-init customizations or not.
|
|
*/
|
|
get cloudInit(): string;
|
|
set cloudInit(val: string);
|
|
/**
|
|
* The image format.
|
|
*/
|
|
get format(): string;
|
|
set format(val: string);
|
|
/**
|
|
* The URL to this image.
|
|
*/
|
|
get url(): string;
|
|
set url(val: string);
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Image.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string, architecture: string, format: string): Image;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Retrieves the target hardware architecture of the OS `image` provides.
|
|
* @returns the hardware architecture, or NULL
|
|
*/
|
|
get_architecture(): string;
|
|
/**
|
|
* Whether `image` supports cloud init customizations
|
|
* @returns #TRUE if @image supports cloud init customizations, #FALSE otherwise.
|
|
*/
|
|
get_cloud_init(): boolean;
|
|
/**
|
|
* The format of the `image`
|
|
* @returns the format, or NULL
|
|
*/
|
|
get_format(): string;
|
|
get_os(): Os;
|
|
/**
|
|
* Gets the varriants of the associated operating system
|
|
* @returns the operating system variants, or NULL
|
|
*/
|
|
get_os_variants(): OsVariantList;
|
|
/**
|
|
* The URL to the `image`
|
|
* @returns the URL, or NULL
|
|
*/
|
|
get_url(): string;
|
|
/**
|
|
* Sets the #OsinfoOs associated to the #OsinfoImage instance.
|
|
* @param os an #OsinfoOs instance
|
|
*/
|
|
set_os(os: Os): void;
|
|
}
|
|
|
|
module ImageList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class ImageList extends List {
|
|
static $gtype: GObject.GType<ImageList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<ImageList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): ImageList;
|
|
}
|
|
|
|
module InstallConfig {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {}
|
|
}
|
|
|
|
class InstallConfig extends Entity {
|
|
static $gtype: GObject.GType<InstallConfig>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<InstallConfig.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string): InstallConfig;
|
|
|
|
// Methods
|
|
|
|
get_admin_password(): string;
|
|
get_avatar_disk(): string;
|
|
get_avatar_location(): string;
|
|
get_driver_signing(): boolean;
|
|
get_hardware_arch(): string;
|
|
get_hostname(): string;
|
|
/**
|
|
* Returns the URL the script will use to perform the installation.
|
|
*/
|
|
get_installation_url(): string;
|
|
get_l10n_keyboard(): string;
|
|
get_l10n_language(): string;
|
|
get_l10n_timezone(): string;
|
|
get_post_install_drivers_disk(): string;
|
|
get_post_install_drivers_location(): string;
|
|
get_pre_install_drivers_disk(): string;
|
|
get_pre_install_drivers_location(): string;
|
|
get_reg_login(): string;
|
|
get_reg_password(): string;
|
|
get_reg_product_key(): string;
|
|
get_script_disk(): string;
|
|
get_target_disk(): string;
|
|
get_user_administrator(): boolean;
|
|
get_user_autologin(): boolean;
|
|
get_user_login(): string;
|
|
get_user_password(): string;
|
|
get_user_realname(): string;
|
|
/**
|
|
* Sets the #OSINFO_INSTALL_CONFIG_PROP_ADMIN_PASSWORD parameter
|
|
* @param password the administrator password to be set
|
|
*/
|
|
set_admin_password(password: string): void;
|
|
/**
|
|
* Sets the #OSINFO_INSTALL_CONFIG_PROP_AVATAR_DISK parameter.
|
|
*
|
|
* Please read documentation on #osinfo_install_config_set_target_disk() for
|
|
* explanation on the format of `disk` string.
|
|
* @param disk the avatar disk
|
|
*/
|
|
set_avatar_disk(disk: string): void;
|
|
/**
|
|
* Sets the #OSINFO_INSTALL_CONFIG_PROP_AVATAR_LOCATION parameter.
|
|
*
|
|
* Note that the format of this string is dependent on the installer script
|
|
* `config` is going to be used with. You can use
|
|
* #osinfo_install_script_get_path_format() to find out which format
|
|
* does the script expects this string to be in.
|
|
*
|
|
* Also note that in case of #OSINFO_PATH_FORMAT_DOS, the drive/disk letter
|
|
* and the leading ':' must not be included in the path.
|
|
* @param location new location
|
|
*/
|
|
set_avatar_location(location: string): void;
|
|
/**
|
|
* If a script requires drivers to be signed, this function can be used to
|
|
* disable that security feature. WARNING: Disabling driver signing may very
|
|
* well mean disabling it permanently.
|
|
* @param signing boolean value
|
|
*/
|
|
set_driver_signing(signing: boolean): void;
|
|
/**
|
|
* Sets the #OSINFO_INSTALL_CONFIG_PROP_HARDWARE_ARCH parameter.
|
|
*
|
|
* The list of valid architectures are part of osinfo.rng schema
|
|
* @param arch the hardware architecture
|
|
*/
|
|
set_hardware_arch(arch: string): void;
|
|
/**
|
|
* Sets the #OSINFO_INSTALL_CONFIG_PROP_HOSTNAME parameter.
|
|
*
|
|
* Note that some operating systems have restrictions on maximum number of, and
|
|
* allowed characters in hostname (or its equivalent) so it is highly
|
|
* recommended that you keep the actual hostname less than or equal to 15
|
|
* characters long and make sure that it does not contain any characters other
|
|
* than ASCII alphanumeric and '-'. Otherwise unattended installation might
|
|
* fail.
|
|
* @param hostname the desired hostname
|
|
*/
|
|
set_hostname(hostname: string): void;
|
|
/**
|
|
* When performing a tree based installation the script will need the installation
|
|
* URL to be set, whenever the installation is performed from a non canonical place.
|
|
* @param url the URL used to perform the installation
|
|
*/
|
|
set_installation_url(url: string): void;
|
|
/**
|
|
* Sets the #OSINFO_INSTALL_CONFIG_PROP_L10N_KEYBOARD parameter.
|
|
*
|
|
* The expected format of this string is the same as
|
|
* #osinfo_install_config_set_l10n_language function's 'language' parameter.
|
|
* @param keyboard the keyboard
|
|
*/
|
|
set_l10n_keyboard(keyboard: string): void;
|
|
/**
|
|
* Sets the #OSINFO_INSTALL_CONFIG_PROP_L10N_LANGUAGE parameter.
|
|
*
|
|
* The expected format of this string is the gettext locale names standard:
|
|
*
|
|
* https://www.gnu.org/savannah-checkouts/gnu/gettext/manual/html_node/Locale-Names.html
|
|
*
|
|
* Encoding and variant are (at least for now) not supported. For example,
|
|
* 'pt_BR' is accepted is accepted as the language codes for Brazilian Portuguese
|
|
* but 'pt_BR.utf8' is not.
|
|
* @param language the language
|
|
*/
|
|
set_l10n_language(language: string): void;
|
|
/**
|
|
* Set the #OSINFO_INSTALL_CONFIG_PROP_L10N_TIMEZONE parameter.
|
|
*
|
|
* The expected format of this string is the tzdata names standard.
|
|
* @param tz the timezone
|
|
*/
|
|
set_l10n_timezone(tz: string): void;
|
|
/**
|
|
* Specify the disk on which drivers to be installed at the end of installation,
|
|
* are available.
|
|
*
|
|
* Please read documentation on #osinfo_install_config_set_target_disk() for
|
|
* explanation on the format of `disk` string.
|
|
*
|
|
* NOTE: Not every install script supports post-installation of drivers. Use
|
|
* #osinfo_install_script_get_can_post_install_drivers() to find out if an
|
|
* install script supports it.
|
|
* @param disk the target disk
|
|
*/
|
|
set_post_install_drivers_disk(disk: string): void;
|
|
/**
|
|
* Specify the disk on which drivers to be installed at the end of installation,
|
|
* are available.
|
|
*
|
|
* Please read documentation on #osinfo_install_config_set_avatar_location() for
|
|
* explanation on the format of `location` string.
|
|
*
|
|
* NOTE: Not every install script supports post-installation of drivers. Use
|
|
* #osinfo_install_script_get_can_post_install_drivers() to find out if an
|
|
* install script supports it.
|
|
* @param location the location of avatar
|
|
*/
|
|
set_post_install_drivers_location(location: string): void;
|
|
/**
|
|
* Specify the disk on which drivers to be installed at the very beginning of
|
|
* installation, are available. This is usually needed for devices for which the
|
|
* OS in question does not have out of the box support for and devices are
|
|
* required/preferred to be available during actual installation.
|
|
*
|
|
* Please read documentation on #osinfo_install_config_set_target_disk() for
|
|
* explanation on the format of `disk` string.
|
|
*
|
|
* NOTE: Not every install script supports pre-installation of drivers. Use
|
|
* #osinfo_install_script_get_can_pre_install_drivers() to find out if an
|
|
* installer script supports it.
|
|
*
|
|
* NOTE: Microsoft Windows XP requires pre-installation driver files to be
|
|
* present in the script disk under the toplevel directory.
|
|
* @param disk the disk
|
|
*/
|
|
set_pre_install_drivers_disk(disk: string): void;
|
|
/**
|
|
* Specify the location on which drivers to be installed at the very beginning of
|
|
* installation, are available. Please read documentation on
|
|
* #osinfo_install_config_set_pre_install_drivers_disk() for more information
|
|
* about pre-installation of drivers.
|
|
*
|
|
* Please read documentation on #osinfo_install_config_set_avatar_location() for
|
|
* explanation on the format of `location` string.
|
|
* @param location the location
|
|
*/
|
|
set_pre_install_drivers_location(location: string): void;
|
|
/**
|
|
* Sets the value of #OSINFO_INSTALL_CONFIG_PROP_REG_LOGIN parameter.
|
|
* @param name the registration login
|
|
*/
|
|
set_reg_login(name: string): void;
|
|
/**
|
|
* Sets the value of #OSINFO_INSTALL_CONFIG_PROP_REG_PASSWORD parameter.
|
|
* @param password the registration password
|
|
*/
|
|
set_reg_password(password: string): void;
|
|
set_reg_product_key(key: string): void;
|
|
/**
|
|
* Sets the #OSINFO_INSTALL_CONFIG_PROP_SCRIPT_DISK parameter.
|
|
*
|
|
* Please read documentation on #osinfo_install_config_set_target_disk() for
|
|
* explanation on the format of `disk` string.
|
|
* @param disk the disk
|
|
*/
|
|
set_script_disk(disk: string): void;
|
|
/**
|
|
* Sets the #OSINFO_INSTALL_CONFIG_PROP_TARGET_DISK parameter.
|
|
*
|
|
* Note that the format of this string is dependent on the installer script
|
|
* `config` is going to be used with. You can use
|
|
* #osinfo_install_script_get_path_format() to find out which format
|
|
* does the script expects this string to be in. In case of
|
|
* #OSINFO_PATH_FORMAT_UNIX unix device node names are expected, e.g "/dev/fd0".
|
|
* In case of #OSINFO_PATH_FORMAT_DOS drive letters are expected, e.g "A".
|
|
* @param disk the target disk
|
|
*/
|
|
set_target_disk(disk: string): void;
|
|
/**
|
|
* Sets the value of #OSINFO_INSTALL_CONFIG_PROP_USER_ADMIN parameter.
|
|
* @param admin whether the user should be set as administrator or not
|
|
*/
|
|
set_user_administrator(admin: boolean): void;
|
|
/**
|
|
* Sets the value of #OSINFO_INSTALL_CONFIG_PROP_USER_AUTOLOGIN parameter.
|
|
* @param autologin whether autologin should be set for the user or not
|
|
*/
|
|
set_user_autologin(autologin: boolean): void;
|
|
/**
|
|
* Sets the value of #OSINFO_INSTALL_CONFIG_PROP_USER_LOGIN parameter.
|
|
* @param username the chosen username for the user log into the system
|
|
*/
|
|
set_user_login(username: string): void;
|
|
/**
|
|
* Sets the #OSINFO_INSTALL_CONFIG_PROP_USER_PASSWORD parameter
|
|
* @param password the user password to be set
|
|
*/
|
|
set_user_password(password: string): void;
|
|
/**
|
|
* Sets the value of #OSINFO_INSTALL_CONFIG_PROP_USER_REALNAME parameter.
|
|
* @param name the user real name to be displayed
|
|
*/
|
|
set_user_realname(name: string): void;
|
|
}
|
|
|
|
module InstallConfigParam {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
name: string;
|
|
policy: InstallConfigParamPolicy;
|
|
value_map: Datamap;
|
|
valueMap: Datamap;
|
|
}
|
|
}
|
|
|
|
class InstallConfigParam extends Entity {
|
|
static $gtype: GObject.GType<InstallConfigParam>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The name of the configuration parameter.
|
|
*/
|
|
get name(): string;
|
|
/**
|
|
* The policy of the configuration parameter.
|
|
*/
|
|
get policy(): InstallConfigParamPolicy;
|
|
/**
|
|
* The mapping between generic values and OS-specific values for this
|
|
* configuration parameter
|
|
*/
|
|
get value_map(): Datamap;
|
|
set value_map(val: Datamap);
|
|
/**
|
|
* The mapping between generic values and OS-specific values for this
|
|
* configuration parameter
|
|
*/
|
|
get valueMap(): Datamap;
|
|
set valueMap(val: Datamap);
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<InstallConfigParam.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](name: string): InstallConfigParam;
|
|
|
|
// Methods
|
|
|
|
get_name(): string;
|
|
get_policy(): InstallConfigParamPolicy;
|
|
get_value_map(): Datamap;
|
|
is_optional(): boolean;
|
|
is_required(): boolean;
|
|
/**
|
|
* After a call to osinfo_install_config_param_set_value_map(), `datamap` will
|
|
* be used to transform values set for this parameter to OS-specific
|
|
* values. A NULL `datamap` will disable transformations.
|
|
* @param datamap a #OsinfoDatamap to transform values this parameter is set to, or NULL to disable transformations for this parameter
|
|
*/
|
|
set_value_map(datamap: Datamap): void;
|
|
}
|
|
|
|
module InstallConfigParamList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class InstallConfigParamList extends List {
|
|
static $gtype: GObject.GType<InstallConfigParamList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<InstallConfigParamList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): InstallConfigParamList;
|
|
}
|
|
|
|
module InstallScript {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
avatar_format: AvatarFormat;
|
|
avatarFormat: AvatarFormat;
|
|
installation_source: InstallScriptInstallationSource;
|
|
installationSource: InstallScriptInstallationSource;
|
|
path_format: PathFormat;
|
|
pathFormat: PathFormat;
|
|
preferred_injection_method: InstallScriptInjectionMethod;
|
|
preferredInjectionMethod: InstallScriptInjectionMethod;
|
|
product_key_format: string;
|
|
productKeyFormat: string;
|
|
profile: string;
|
|
template_data: string;
|
|
templateData: string;
|
|
template_uri: string;
|
|
templateUri: string;
|
|
}
|
|
}
|
|
|
|
class InstallScript extends Entity {
|
|
static $gtype: GObject.GType<InstallScript>;
|
|
|
|
// Properties
|
|
|
|
get avatar_format(): AvatarFormat;
|
|
get avatarFormat(): AvatarFormat;
|
|
get installation_source(): InstallScriptInstallationSource;
|
|
get installationSource(): InstallScriptInstallationSource;
|
|
get path_format(): PathFormat;
|
|
get pathFormat(): PathFormat;
|
|
get preferred_injection_method(): InstallScriptInjectionMethod;
|
|
set preferred_injection_method(val: InstallScriptInjectionMethod);
|
|
get preferredInjectionMethod(): InstallScriptInjectionMethod;
|
|
set preferredInjectionMethod(val: InstallScriptInjectionMethod);
|
|
get product_key_format(): string;
|
|
get productKeyFormat(): string;
|
|
get profile(): string;
|
|
get template_data(): string;
|
|
get templateData(): string;
|
|
get template_uri(): string;
|
|
get templateUri(): string;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<InstallScript.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string): InstallScript;
|
|
|
|
static new_data(id: string, profile: string, templateData: string): InstallScript;
|
|
|
|
static new_uri(id: string, profile: string, templateUri: string): InstallScript;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Creates an install script.
|
|
* @param os the os
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @returns the script as string. If you are generating the script for a specific media, it is recommended that you use #osinfo_install_script_generate_for_media() instead. If you are generating the script for a specific tree, it is recommended that you use #osinfo_install_script_generate_for_tree() in instead.
|
|
*/
|
|
generate(os: Os, config: InstallConfig, cancellable?: Gio.Cancellable | null): string;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate(). From the callback,
|
|
* call #osinfo_install_script_generate_finish() to conclude this call and get
|
|
* the generated script.
|
|
*
|
|
* If you are generating the script for a specific media, it is recommended that
|
|
* you use #osinfo_install_script_generate_for_media_async() instead.
|
|
* @param os the os
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
*/
|
|
generate_async(os: Os, config: InstallConfig, cancellable?: Gio.Cancellable | null): Promise<string>;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate(). From the callback,
|
|
* call #osinfo_install_script_generate_finish() to conclude this call and get
|
|
* the generated script.
|
|
*
|
|
* If you are generating the script for a specific media, it is recommended that
|
|
* you use #osinfo_install_script_generate_for_media_async() instead.
|
|
* @param os the os
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_async(
|
|
os: Os,
|
|
config: InstallConfig,
|
|
cancellable: Gio.Cancellable | null,
|
|
callback: Gio.AsyncReadyCallback<this> | null,
|
|
): void;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate(). From the callback,
|
|
* call #osinfo_install_script_generate_finish() to conclude this call and get
|
|
* the generated script.
|
|
*
|
|
* If you are generating the script for a specific media, it is recommended that
|
|
* you use #osinfo_install_script_generate_for_media_async() instead.
|
|
* @param os the os
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_async(
|
|
os: Os,
|
|
config: InstallConfig,
|
|
cancellable?: Gio.Cancellable | null,
|
|
callback?: Gio.AsyncReadyCallback<this> | null,
|
|
): Promise<string> | void;
|
|
/**
|
|
* Some install scripts need to pass a command line to the kernel, Such install
|
|
* scripts belong to OSs that provide paths to the kernel and initrd files that
|
|
* can be used to directly boot
|
|
* (http://wiki.qemu.org/download/qemu-doc.html#direct_005flinux_005fboot)
|
|
* the OS in order to pass the needed commandline to it.
|
|
*
|
|
* If you are generating the command line for a specific media, it is
|
|
* recommended that you use
|
|
* #osinfo_install_script_generate_command_line_for_media() instead.
|
|
*
|
|
* If you are generating the command line for a specific tree, it is
|
|
* recommended that you use
|
|
* #osinfo_install_script_generate_command_line_for_tree() instead.
|
|
* @param os the os entity
|
|
* @param config the install script config
|
|
* @returns The generated command line string, NULL otherwise.
|
|
*/
|
|
generate_command_line(os: Os, config: InstallConfig): string;
|
|
/**
|
|
* Some install scripts need to pass a command line to the kernel, Such install
|
|
* scripts belong to OSs that provide paths to the kernel and initrd files that
|
|
* can be used to directly boot
|
|
* (http://wiki.qemu.org/download/qemu-doc.html#direct_005flinux_005fboot)
|
|
* the OS in order to pass the needed commandline to it.
|
|
*
|
|
* The media `media` must have been identified successfully using
|
|
* #osinfo_db_identify_media() before calling this function.
|
|
* @param media the media
|
|
* @param config the install script config
|
|
* @returns The generated command line string, NULL otherwise.
|
|
*/
|
|
generate_command_line_for_media(media: Media, config: InstallConfig): string;
|
|
/**
|
|
* Some install scripts need to pass a command line to the kernel, Such install
|
|
* scripts belong to OSs that provide paths to the kernel and initrd files that
|
|
* can be used to directly boot
|
|
* (http://wiki.qemu.org/download/qemu-doc.html#direct_005flinux_005fboot)
|
|
* the OS in order to pass the needed commandline to it.
|
|
*
|
|
* The tree `tree` must have been identified successfully using
|
|
* #osinfo_db_identify_tree() before calling this function.
|
|
* @param tree the tree
|
|
* @param config the install script config
|
|
* @returns The generated command line string, NULL otherwise.
|
|
*/
|
|
generate_command_line_for_tree(tree: Tree, config: InstallConfig): string;
|
|
generate_finish(res: Gio.AsyncResult): string;
|
|
/**
|
|
* Creates an install script. The media `media` must have been identified
|
|
* successfully using #osinfo_db_identify_media() before calling this function.
|
|
* @param media the media
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @returns the script as string.
|
|
*/
|
|
generate_for_media(media: Media, config: InstallConfig, cancellable?: Gio.Cancellable | null): string;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_for_media(). From the
|
|
* callback, call #osinfo_install_script_generate_for_media_finish() to
|
|
* conclude this call and get the generated script.
|
|
* @param media the media
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
*/
|
|
generate_for_media_async(
|
|
media: Media,
|
|
config: InstallConfig,
|
|
cancellable?: Gio.Cancellable | null,
|
|
): Promise<string>;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_for_media(). From the
|
|
* callback, call #osinfo_install_script_generate_for_media_finish() to
|
|
* conclude this call and get the generated script.
|
|
* @param media the media
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_for_media_async(
|
|
media: Media,
|
|
config: InstallConfig,
|
|
cancellable: Gio.Cancellable | null,
|
|
callback: Gio.AsyncReadyCallback<this> | null,
|
|
): void;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_for_media(). From the
|
|
* callback, call #osinfo_install_script_generate_for_media_finish() to
|
|
* conclude this call and get the generated script.
|
|
* @param media the media
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_for_media_async(
|
|
media: Media,
|
|
config: InstallConfig,
|
|
cancellable?: Gio.Cancellable | null,
|
|
callback?: Gio.AsyncReadyCallback<this> | null,
|
|
): Promise<string> | void;
|
|
generate_for_media_finish(res: Gio.AsyncResult): string;
|
|
/**
|
|
* Creates an install script. The tree `tree` must have been identified
|
|
* successfully using #osinfo_db_identify_tree() before calling this function.
|
|
* @param tree the tree
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @returns the script as string.
|
|
*/
|
|
generate_for_tree(tree: Tree, config: InstallConfig, cancellable?: Gio.Cancellable | null): string;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_for_tree(). From the
|
|
* callback, call #osinfo_install_script_generate_for_tree_finish() to
|
|
* conclude this call and get the generated script.
|
|
* @param tree the tree
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
*/
|
|
generate_for_tree_async(
|
|
tree: Tree,
|
|
config: InstallConfig,
|
|
cancellable?: Gio.Cancellable | null,
|
|
): Promise<string>;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_for_tree(). From the
|
|
* callback, call #osinfo_install_script_generate_for_tree_finish() to
|
|
* conclude this call and get the generated script.
|
|
* @param tree the tree
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_for_tree_async(
|
|
tree: Tree,
|
|
config: InstallConfig,
|
|
cancellable: Gio.Cancellable | null,
|
|
callback: Gio.AsyncReadyCallback<this> | null,
|
|
): void;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_for_tree(). From the
|
|
* callback, call #osinfo_install_script_generate_for_tree_finish() to
|
|
* conclude this call and get the generated script.
|
|
* @param tree the tree
|
|
* @param config the install script config
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_for_tree_async(
|
|
tree: Tree,
|
|
config: InstallConfig,
|
|
cancellable?: Gio.Cancellable | null,
|
|
callback?: Gio.AsyncReadyCallback<this> | null,
|
|
): Promise<string> | void;
|
|
generate_for_tree_finish(res: Gio.AsyncResult): string;
|
|
/**
|
|
* Creates an install script that is written to the returned file.
|
|
* @param os the os entity
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @returns a file containing the script If you are generating the script for a specific media, it is recommended that you use #osinfo_install_script_generate_output_for_media() instead. If you are generating the script for a specific tree, it is recommended that you use #osinfo_install_script_generate_output_for_tree() instead.
|
|
*/
|
|
generate_output(
|
|
os: Os,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable?: Gio.Cancellable | null,
|
|
): Gio.File;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_output(). From the
|
|
* callback, call #osinfo_install_script_generate_output_finish() to conclude
|
|
* this call and get the generated script.
|
|
*
|
|
* If you are generating the script for a specific media, it is recommended that
|
|
* you use #osinfo_install_script_generate_output_for_media_async() instead.
|
|
* @param os the os
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
*/
|
|
generate_output_async(
|
|
os: Os,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable?: Gio.Cancellable | null,
|
|
): Promise<Gio.File>;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_output(). From the
|
|
* callback, call #osinfo_install_script_generate_output_finish() to conclude
|
|
* this call and get the generated script.
|
|
*
|
|
* If you are generating the script for a specific media, it is recommended that
|
|
* you use #osinfo_install_script_generate_output_for_media_async() instead.
|
|
* @param os the os
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_output_async(
|
|
os: Os,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable: Gio.Cancellable | null,
|
|
callback: Gio.AsyncReadyCallback<this> | null,
|
|
): void;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_output(). From the
|
|
* callback, call #osinfo_install_script_generate_output_finish() to conclude
|
|
* this call and get the generated script.
|
|
*
|
|
* If you are generating the script for a specific media, it is recommended that
|
|
* you use #osinfo_install_script_generate_output_for_media_async() instead.
|
|
* @param os the os
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_output_async(
|
|
os: Os,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable?: Gio.Cancellable | null,
|
|
callback?: Gio.AsyncReadyCallback<this> | null,
|
|
): Promise<Gio.File> | void;
|
|
generate_output_finish(res: Gio.AsyncResult): Gio.File;
|
|
/**
|
|
* Creates an install script that is written to the returned file.
|
|
* @param media the media
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @returns a file containing the script.
|
|
*/
|
|
generate_output_for_media(
|
|
media: Media,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable?: Gio.Cancellable | null,
|
|
): Gio.File;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_output_for_media().
|
|
* From the callback, call
|
|
* #osinfo_install_script_generate_output_for_media_finish() to conclude this
|
|
* call and get the generated file.
|
|
* @param media the media
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
*/
|
|
generate_output_for_media_async(
|
|
media: Media,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable?: Gio.Cancellable | null,
|
|
): Promise<Gio.File>;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_output_for_media().
|
|
* From the callback, call
|
|
* #osinfo_install_script_generate_output_for_media_finish() to conclude this
|
|
* call and get the generated file.
|
|
* @param media the media
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_output_for_media_async(
|
|
media: Media,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable: Gio.Cancellable | null,
|
|
callback: Gio.AsyncReadyCallback<this> | null,
|
|
): void;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_output_for_media().
|
|
* From the callback, call
|
|
* #osinfo_install_script_generate_output_for_media_finish() to conclude this
|
|
* call and get the generated file.
|
|
* @param media the media
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_output_for_media_async(
|
|
media: Media,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable?: Gio.Cancellable | null,
|
|
callback?: Gio.AsyncReadyCallback<this> | null,
|
|
): Promise<Gio.File> | void;
|
|
generate_output_for_media_finish(res: Gio.AsyncResult): Gio.File;
|
|
/**
|
|
* Creates an install script that is written to the returned file.
|
|
* @param tree the tree
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @returns a file containing the script.
|
|
*/
|
|
generate_output_for_tree(
|
|
tree: Tree,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable?: Gio.Cancellable | null,
|
|
): Gio.File;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_output_for_tree().
|
|
* From the callback, call
|
|
* #osinfo_install_script_generate_output_for_tree_finish() to conclude this
|
|
* call and get the generated file.
|
|
* @param tree the tree
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
*/
|
|
generate_output_for_tree_async(
|
|
tree: Tree,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable?: Gio.Cancellable | null,
|
|
): Promise<Gio.File>;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_output_for_tree().
|
|
* From the callback, call
|
|
* #osinfo_install_script_generate_output_for_tree_finish() to conclude this
|
|
* call and get the generated file.
|
|
* @param tree the tree
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_output_for_tree_async(
|
|
tree: Tree,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable: Gio.Cancellable | null,
|
|
callback: Gio.AsyncReadyCallback<this> | null,
|
|
): void;
|
|
/**
|
|
* Asynchronous variant of #osinfo_install_script_generate_output_for_tree().
|
|
* From the callback, call
|
|
* #osinfo_install_script_generate_output_for_tree_finish() to conclude this
|
|
* call and get the generated file.
|
|
* @param tree the tree
|
|
* @param config the install script config
|
|
* @param output_dir the directory where the file containing the output script will be written
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
generate_output_for_tree_async(
|
|
tree: Tree,
|
|
config: InstallConfig,
|
|
output_dir: Gio.File,
|
|
cancellable?: Gio.Cancellable | null,
|
|
callback?: Gio.AsyncReadyCallback<this> | null,
|
|
): Promise<Gio.File> | void;
|
|
generate_output_for_tree_finish(res: Gio.AsyncResult): Gio.File;
|
|
/**
|
|
* Some install scripts have restrictions on the format of the user avatar. Use
|
|
* this method to retrieve those restrictions in the form of an
|
|
* #OsinfoAvatarFormat instance.
|
|
* @returns The avatar format, or NULL if there is no restrictions on the format of avatar
|
|
*/
|
|
get_avatar_format(): AvatarFormat;
|
|
/**
|
|
* Whether install script can install drivers at the very end of installation
|
|
* This can be used for installing devices which the OS in question does not
|
|
* have out of the box support.
|
|
* @returns TRUE if install script supports post-installable drivers, FALSE otherwise.
|
|
*/
|
|
get_can_post_install_drivers(): boolean;
|
|
/**
|
|
* Whether install script can install drivers at the very beginning of
|
|
* installation. This is needed for devices for which the OS in question does
|
|
* not have out of the box support for and devices are required/preferred to be
|
|
* available during actual installation.
|
|
* @returns TRUE if install script supports pre-installable drivers, FALSE otherwise.
|
|
*/
|
|
get_can_pre_install_drivers(): boolean;
|
|
/**
|
|
* Get a config param from the config param's list
|
|
* @param name name of the parameter
|
|
* @returns the sought config param, if exists. NULL otherwise. This code assumes that the 'id' and 'name' entity properties are the same.
|
|
*/
|
|
get_config_param(name: string): InstallConfigParam;
|
|
/**
|
|
* Get the list of valid config parameters for `script`.
|
|
* @returns the list of valid #OsinfoInstallConfigParam parameters. Free with g_list_free() when done. The elements are owned by libosinfo.
|
|
*/
|
|
get_config_param_list(): InstallScript[];
|
|
/**
|
|
* Get the list of valid config parameters for `script`.
|
|
* @returns the list of valid #OsinfoInstallConfigParam parameters.
|
|
*/
|
|
get_config_params(): InstallConfigParamList;
|
|
/**
|
|
* Some operating systems (as Windows) expect that script filename has
|
|
* particular name to work.
|
|
* @returns the expected script filename
|
|
*/
|
|
get_expected_filename(): string;
|
|
/**
|
|
* Retrieve the supported method to inject the script in to the installation process.
|
|
* @returns bitwise-or of supported methods for install script injection.
|
|
*/
|
|
get_injection_methods(): InstallScriptInjectionMethod;
|
|
get_installation_source(): InstallScriptInstallationSource;
|
|
/**
|
|
* Some install scripts cannot ensure that they work without an internet connection.
|
|
* @returns TRUE if script needs an internet connection, FALSE otherwise internet connection.
|
|
*/
|
|
get_needs_internet(): boolean;
|
|
/**
|
|
* Some operating systems are able to use any script filename, allowing the
|
|
* application to set the filename as desired. libosinfo provides this
|
|
* functionality by set the expected filename's prefix using
|
|
* osinfo_install_script_set_output_prefix() function.
|
|
* @returns the output script filename
|
|
*/
|
|
get_output_filename(): string;
|
|
get_output_prefix(): string;
|
|
/**
|
|
* Returns the path format to be used for the files and disks which will
|
|
* be used during the installation.
|
|
* @returns the path format to be used. OSINFO_PATH_FORMAT_UNIX is the default option.
|
|
*/
|
|
get_path_format(): PathFormat;
|
|
/**
|
|
* If install script can install drivers at the end of installation, this
|
|
* function retrieves the requirement about signed status of drivers.
|
|
*/
|
|
get_post_install_drivers_signing_req(): DeviceDriverSigningReq;
|
|
/**
|
|
* If install script can install drivers at the very beginning of installation,
|
|
* this function retrieves the requirement about signed status of drivers.
|
|
*/
|
|
get_pre_install_drivers_signing_req(): DeviceDriverSigningReq;
|
|
get_preferred_injection_method(): InstallScriptInjectionMethod;
|
|
/**
|
|
* If this function returns a non-NULL string, it means that the `script`
|
|
* requires you to specify product registration key through #OsinfoInstallConfig
|
|
* instance passed to script generation methods.
|
|
*
|
|
* The returned string specifies the expected format of the product key like this:
|
|
*
|
|
* @ - any character
|
|
* % - alphabet
|
|
* # - numeric character
|
|
* $ - alphanumeric character
|
|
*
|
|
* All other characters represent themselves.
|
|
*
|
|
* For example in case of installer for Microsoft Windows XP, you'll get
|
|
* "$$$$$-$$$$$-$$$$$-$$$$$-$$$$$". That means a product key consists of 24
|
|
* alphanumeric characters and 4 '-' characters at (0-based) indices 5, 11, 17
|
|
* and 23.
|
|
* @returns Product key format mask, or NULL.
|
|
*/
|
|
get_product_key_format(): string;
|
|
/**
|
|
* Returns a string representing the install script profile that's going to be
|
|
* used.
|
|
*
|
|
* The values supported are "jeos" for minimal installations and "desktop" for
|
|
* workstation/desktop installations.
|
|
*/
|
|
get_profile(): string;
|
|
/**
|
|
* Returns the stylesheet data used to construct the install script.
|
|
*/
|
|
get_template_data(): string;
|
|
/**
|
|
* Returns the stylesheet URI used to construct the install script.
|
|
*/
|
|
get_template_uri(): string;
|
|
/**
|
|
* Returns whether the `script` has the `config_param` searched or not.
|
|
*
|
|
* This code assumes that the 'id' and 'name' entity properties are the same.
|
|
* @param config_param an #OsinfoInstallConfigParam
|
|
*/
|
|
has_config_param(config_param: InstallConfigParam): boolean;
|
|
/**
|
|
* Returns whether the `script` has a configuration parameter matching `name` or not.
|
|
* @param name the configuration parameter name
|
|
*/
|
|
has_config_param_name(name: string): boolean;
|
|
/**
|
|
* Set the installation source to be used with the `script`.
|
|
* @param source one of the installation sources: OSINFO_INSTALL_SCRIPT_INSTALLATION_SOURCE_MEDIA, OSINFO_INSTALL_SCRIPT_INSTALLATION_SOURCE_NETWORK
|
|
*/
|
|
set_installation_source(source: InstallScriptInstallationSource | null): void;
|
|
/**
|
|
* Mind that not all installers support any name for the installer scripts.
|
|
* @param prefix a prefix to be added to the file generated
|
|
*/
|
|
set_output_prefix(prefix: string): void;
|
|
/**
|
|
* Set the preferred injection method to be used with the `script`
|
|
* @param method one of the injection methods: OSINFO_INSTALL_SCRIPT_INJECTION_METHOD_CDROM, OSINFO_INSTALL_SCRIPT_INJECTION_METHOD_DISK, OSINFO_INSTALL_SCRIPT_INJECTION_METHOD_FLOPPY, OSINFO_INSTALL_SCRIPT_INJECTION_METHOD_INITRD, OSINFO_INSTALL_SCRIPT_INJECTION_METHOD_WEB
|
|
*/
|
|
set_preferred_injection_method(method: InstallScriptInjectionMethod | null): void;
|
|
}
|
|
|
|
module InstallScriptList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class InstallScriptList extends List {
|
|
static $gtype: GObject.GType<InstallScriptList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<InstallScriptList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): InstallScriptList;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Construct a new install_script list that is filled with install_scripts
|
|
* from `source`
|
|
* @returns a copy of the install_script list
|
|
*/
|
|
new_copy(): InstallScriptList;
|
|
/**
|
|
* Construct a new install_script list that is filled with install_scripts
|
|
* from `source` that match `filter`
|
|
* @param filter the filter to apply
|
|
* @returns a filtered copy of the install_script list
|
|
*/
|
|
new_filtered(filter: Filter): InstallScriptList;
|
|
/**
|
|
* Construct a new install_script list that is filled with only the
|
|
* install_scripts that are present in both `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second install_script list to copy
|
|
* @returns an intersection of the two install_script lists
|
|
*/
|
|
new_intersection(sourceTwo: InstallScriptList): InstallScriptList;
|
|
/**
|
|
* Construct a new install_script list that is filled with all the
|
|
* install_scripts that are present in either `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second install_script list to copy
|
|
* @returns a union of the two install_script lists
|
|
*/
|
|
new_union(sourceTwo: InstallScriptList): InstallScriptList;
|
|
}
|
|
|
|
module List {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {
|
|
element_type: GObject.GType;
|
|
elementType: GObject.GType;
|
|
}
|
|
}
|
|
|
|
abstract class List extends GObject.Object {
|
|
static $gtype: GObject.GType<List>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The specialization of the list. The list will be
|
|
* restricted to storing #OsinfoEntity objects of
|
|
* the specified type.
|
|
*/
|
|
get element_type(): GObject.GType;
|
|
/**
|
|
* The specialization of the list. The list will be
|
|
* restricted to storing #OsinfoEntity objects of
|
|
* the specified type.
|
|
*/
|
|
get elementType(): GObject.GType;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<List.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Adds a new entity to the list.
|
|
* @param entity the entity to add to the list
|
|
*/
|
|
add(entity: Entity): void;
|
|
/**
|
|
* Adds all entities from `source` to `list`. Using one
|
|
* of the constructors in a subclass is preferable
|
|
* to this method.
|
|
* @param source the list to add
|
|
*/
|
|
add_all(source: List): void;
|
|
/**
|
|
* Adds all entities from `source` which are matched by `filter`. Using one
|
|
* of the constructors in a subclass is preferable
|
|
* to this method.
|
|
* @param source the source for elements
|
|
* @param filter filter to process the source with
|
|
*/
|
|
add_filtered(source: List, filter: Filter): void;
|
|
/**
|
|
* Computes the intersection between `sourceOne` and `sourceTwo` and
|
|
* adds the resulting list of entities to the `list`. Using one
|
|
* of the constructors in a subclass is preferable
|
|
* to this method.
|
|
* @param sourceOne the first list to add
|
|
* @param sourceTwo the second list to add
|
|
*/
|
|
add_intersection(sourceOne: List, sourceTwo: List): void;
|
|
/**
|
|
* Computes the union between `sourceOne` and `sourceTwo` and
|
|
* adds the resulting list of entities to the `list`. Using one
|
|
* of the constructors in a subclass is preferable
|
|
* to this method.
|
|
* @param sourceOne the first list to add
|
|
* @param sourceTwo the second list to add
|
|
*/
|
|
add_union(sourceOne: List, sourceTwo: List): void;
|
|
/**
|
|
* Search the list looking for the entity with a matching
|
|
* unique identifier.
|
|
* @param id the unique identifier
|
|
* @returns the matching entity, or NULL
|
|
*/
|
|
find_by_id(id: string): Entity;
|
|
/**
|
|
* Retrieves the type of the subclass of #OsinfoEntity
|
|
* that may be stored in the list
|
|
* @returns the type of entity stored
|
|
*/
|
|
get_element_type(): GObject.GType;
|
|
/**
|
|
* Retrieve a linked list of all elements in the list.
|
|
* @returns the list elements
|
|
*/
|
|
get_elements(): Entity[];
|
|
/**
|
|
* Retrieves the number of elements currently stored
|
|
* in the list
|
|
* @returns the list length
|
|
*/
|
|
get_length(): number;
|
|
/**
|
|
* Retrieves the element in the list at position `idx`. If
|
|
* `idx` is less than zero, or greater than the number of
|
|
* elements in the list, the results are undefined.
|
|
* @param idx the list position to fetch
|
|
* @returns the list element or %NULL
|
|
*/
|
|
get_nth(idx: number): Entity;
|
|
/**
|
|
* Construct a new list that is filled with elements from `source`
|
|
* @returns a copy of the list
|
|
*/
|
|
new_copy(): List;
|
|
/**
|
|
* Construct a new list that is filled with elements from `source` that
|
|
* match `filter`
|
|
* @param filter the filter to apply
|
|
* @returns a filtered copy of the list
|
|
*/
|
|
new_filtered(filter: Filter): List;
|
|
/**
|
|
* Construct a new list that is filled with only the elements
|
|
* that are present in both `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second list to copy
|
|
* @returns an intersection of the two lists
|
|
*/
|
|
new_intersection(sourceTwo: List): List;
|
|
/**
|
|
* Construct a new list that is filled with all the that are present in
|
|
* either `sourceOne` and `sourceTwo`. `sourceOne` and `sourceTwo` must be of
|
|
* the same type.
|
|
* @param sourceTwo the second list to copy
|
|
* @returns a union of the two lists
|
|
*/
|
|
new_union(sourceTwo: List): List;
|
|
}
|
|
|
|
module Loader {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends GObject.Object.ConstructorProps {}
|
|
}
|
|
|
|
class Loader extends GObject.Object {
|
|
static $gtype: GObject.GType<Loader>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Loader.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): Loader;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Retrieves the database being populated
|
|
* @returns the database
|
|
*/
|
|
get_db(): Db;
|
|
process_default_path(): void;
|
|
/**
|
|
* Loads data from the local path.
|
|
*/
|
|
process_local_path(): void;
|
|
/**
|
|
* Loads data from the specified path. If the path
|
|
* points to a file, that will be loaded as XML
|
|
* Otherwise it can point to a directory which will
|
|
* be recursively traversed, loading all files as XML.
|
|
* @param path the fully qualified path
|
|
*/
|
|
process_path(path: string): void;
|
|
/**
|
|
* Loads data from the system path.
|
|
*/
|
|
process_system_path(): void;
|
|
/**
|
|
* Loads data from the specified URI. If the URI
|
|
* points to a file, that will be loaded as XML
|
|
* Otherwise it can point to a directory which will
|
|
* be recursively traversed, loading all files as XML.
|
|
* @param uri the data source URI
|
|
*/
|
|
process_uri(uri: string): void;
|
|
/**
|
|
* Loads data from user path.
|
|
*/
|
|
process_user_path(): void;
|
|
}
|
|
|
|
module Media {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
application_id: string;
|
|
applicationId: string;
|
|
architecture: string;
|
|
eject_after_install: boolean;
|
|
ejectAfterInstall: boolean;
|
|
initrd_path: string;
|
|
initrdPath: string;
|
|
installer: boolean;
|
|
installer_reboots: number;
|
|
installerReboots: number;
|
|
installer_script: boolean;
|
|
installerScript: boolean;
|
|
kernel_path: string;
|
|
kernelPath: string;
|
|
languages: string[];
|
|
live: boolean;
|
|
os: Os;
|
|
publisher_id: string;
|
|
publisherId: string;
|
|
system_id: string;
|
|
systemId: string;
|
|
url: string;
|
|
volume_id: string;
|
|
volumeId: string;
|
|
volume_size: number;
|
|
volumeSize: number;
|
|
}
|
|
}
|
|
|
|
class Media extends Entity {
|
|
static $gtype: GObject.GType<Media>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* Expected application ID (regular expression) for ISO9660 image/device.
|
|
*/
|
|
get application_id(): string;
|
|
set application_id(val: string);
|
|
/**
|
|
* Expected application ID (regular expression) for ISO9660 image/device.
|
|
*/
|
|
get applicationId(): string;
|
|
set applicationId(val: string);
|
|
/**
|
|
* The target hardware architecture of this media.
|
|
*/
|
|
get architecture(): string;
|
|
set architecture(val: string);
|
|
/**
|
|
* Whether the media should be ejected after the installation process.
|
|
*
|
|
* Some distros need their media to not be ejected after the final reboot
|
|
* during its installation process as some packages are installed after the
|
|
* reboot (which may cause the media to be ejected, depending on the
|
|
* application).
|
|
*/
|
|
get eject_after_install(): boolean;
|
|
set eject_after_install(val: boolean);
|
|
/**
|
|
* Whether the media should be ejected after the installation process.
|
|
*
|
|
* Some distros need their media to not be ejected after the final reboot
|
|
* during its installation process as some packages are installed after the
|
|
* reboot (which may cause the media to be ejected, depending on the
|
|
* application).
|
|
*/
|
|
get ejectAfterInstall(): boolean;
|
|
set ejectAfterInstall(val: boolean);
|
|
/**
|
|
* The path to the initrd image in the install tree.
|
|
*/
|
|
get initrd_path(): string;
|
|
set initrd_path(val: string);
|
|
/**
|
|
* The path to the initrd image in the install tree.
|
|
*/
|
|
get initrdPath(): string;
|
|
set initrdPath(val: string);
|
|
/**
|
|
* Whether media provides an installer for an OS.
|
|
*/
|
|
get installer(): boolean;
|
|
set installer(val: boolean);
|
|
/**
|
|
* If media is an installer, this property indicates the number of reboots
|
|
* the installer takes before installation is complete.
|
|
*
|
|
* This property is not applicable to media that has no installer. You can
|
|
* use #osinfo_media_get_installer(or OsinfoMedia::installer) to check
|
|
* that.
|
|
*
|
|
* Warning: Some media allow you to install from live sessions, in which
|
|
* case number of reboots *alone* is not a reliable method for tracking
|
|
* installation.
|
|
*/
|
|
get installer_reboots(): number;
|
|
set installer_reboots(val: number);
|
|
/**
|
|
* If media is an installer, this property indicates the number of reboots
|
|
* the installer takes before installation is complete.
|
|
*
|
|
* This property is not applicable to media that has no installer. You can
|
|
* use #osinfo_media_get_installer(or OsinfoMedia::installer) to check
|
|
* that.
|
|
*
|
|
* Warning: Some media allow you to install from live sessions, in which
|
|
* case number of reboots *alone* is not a reliable method for tracking
|
|
* installation.
|
|
*/
|
|
get installerReboots(): number;
|
|
set installerReboots(val: number);
|
|
/**
|
|
* Whether the media supports installation via an install-script.
|
|
*
|
|
* Some distros provide a few different medias and not all the medias support
|
|
* installation via an install script.
|
|
*/
|
|
get installer_script(): boolean;
|
|
set installer_script(val: boolean);
|
|
/**
|
|
* Whether the media supports installation via an install-script.
|
|
*
|
|
* Some distros provide a few different medias and not all the medias support
|
|
* installation via an install script.
|
|
*/
|
|
get installerScript(): boolean;
|
|
set installerScript(val: boolean);
|
|
/**
|
|
* The path to the kernel image in the install tree.
|
|
*/
|
|
get kernel_path(): string;
|
|
set kernel_path(val: string);
|
|
/**
|
|
* The path to the kernel image in the install tree.
|
|
*/
|
|
get kernelPath(): string;
|
|
set kernelPath(val: string);
|
|
/**
|
|
* If media is an installer, this property indicates the languages that
|
|
* can be used during automatic installations.
|
|
*
|
|
* On media that are not installers, this property will indicate the
|
|
* languages that the user interface can be displayed in.
|
|
* Use #osinfo_media_get_installer(or OsinfoMedia::installer) to know
|
|
* if the media is an installer or not.
|
|
*/
|
|
get languages(): string[];
|
|
/**
|
|
* Whether media can boot directly an OS without any installations.
|
|
*/
|
|
get live(): boolean;
|
|
set live(val: boolean);
|
|
/**
|
|
* Os information for the current media. For media stored in an
|
|
* #OsinfoDb, it will be filled when the database is loaded, otherwise
|
|
* the property will be filled after a successful call to
|
|
* osinfo_db_identify_media().
|
|
*/
|
|
get os(): Os;
|
|
set os(val: Os);
|
|
/**
|
|
* Expected publisher ID (regular expression) for ISO9660 image/device.
|
|
*/
|
|
get publisher_id(): string;
|
|
set publisher_id(val: string);
|
|
/**
|
|
* Expected publisher ID (regular expression) for ISO9660 image/device.
|
|
*/
|
|
get publisherId(): string;
|
|
set publisherId(val: string);
|
|
/**
|
|
* Expected system ID (regular expression) for ISO9660 image/device.
|
|
*/
|
|
get system_id(): string;
|
|
set system_id(val: string);
|
|
/**
|
|
* Expected system ID (regular expression) for ISO9660 image/device.
|
|
*/
|
|
get systemId(): string;
|
|
set systemId(val: string);
|
|
/**
|
|
* The URL to this media.
|
|
*/
|
|
get url(): string;
|
|
set url(val: string);
|
|
/**
|
|
* Expected volume ID (regular expression) for ISO9660 image/device.
|
|
*/
|
|
get volume_id(): string;
|
|
set volume_id(val: string);
|
|
/**
|
|
* Expected volume ID (regular expression) for ISO9660 image/device.
|
|
*/
|
|
get volumeId(): string;
|
|
set volumeId(val: string);
|
|
/**
|
|
* Expected volume size, in bytes for ISO9660 image/device.
|
|
*/
|
|
get volume_size(): number;
|
|
set volume_size(val: number);
|
|
/**
|
|
* Expected volume size, in bytes for ISO9660 image/device.
|
|
*/
|
|
get volumeSize(): number;
|
|
set volumeSize(val: number);
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Media.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string, architecture: string): Media;
|
|
|
|
// Static methods
|
|
|
|
/**
|
|
* Creates a new #OsinfoMedia for installation media at `location`. The `location`
|
|
* could be a http:// or a https:// URI or a local path.
|
|
*
|
|
* NOTE: Currently this only works for ISO images/devices.
|
|
* @param location the location of an installation media
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
*/
|
|
static create_from_location(location: string, cancellable?: Gio.Cancellable | null): Media;
|
|
/**
|
|
* Asynchronous variant of #osinfo_media_create_from_location.
|
|
* @param location the location of an installation media
|
|
* @param priority the I/O priority of the request
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
static create_from_location_async(
|
|
location: string,
|
|
priority: number,
|
|
cancellable?: Gio.Cancellable | null,
|
|
callback?: Gio.AsyncReadyCallback<Media> | null,
|
|
): void;
|
|
/**
|
|
* Finishes an asynchronous media object creation process started with
|
|
* #osinfo_media_create_from_location_async.
|
|
* @param res a #GAsyncResult
|
|
*/
|
|
static create_from_location_finish(res: Gio.AsyncResult): Media;
|
|
/**
|
|
* Creates a new #OsinfoMedia for installation media at `location`. The `location`
|
|
* could be a http:// or a https:// URI or a local path.
|
|
*
|
|
* NOTE: Currently this only works for ISO images/devices.
|
|
* @param location the location of an installation media
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param flags An #OsinfoMediaDetectFlag, or 0.
|
|
*/
|
|
static create_from_location_with_flags(
|
|
location: string,
|
|
cancellable: Gio.Cancellable | null,
|
|
flags: number,
|
|
): Media;
|
|
/**
|
|
* Asynchronous variant of #osinfo_media_create_from_location_with_flags.
|
|
* @param location the location of an installation media
|
|
* @param priority the I/O priority of the request
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
* @param flags An #OsinfoMediaDetectFlag, or 0.
|
|
*/
|
|
static create_from_location_with_flags_async(
|
|
location: string,
|
|
priority: number,
|
|
cancellable: Gio.Cancellable | null,
|
|
callback: Gio.AsyncReadyCallback<Media> | null,
|
|
flags: number,
|
|
): void;
|
|
/**
|
|
* Finishes an asynchronous media object creation process started with
|
|
* #osinfo_media_create_from_location_async.
|
|
* @param res a #GAsyncResult
|
|
*/
|
|
static create_from_location_with_flags_finish(res: Gio.AsyncResult): Media;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Adds an `script` to the specified `media`
|
|
* @param script an #OsinfoInstallScript instance
|
|
*/
|
|
add_install_script(script: InstallScript): void;
|
|
/**
|
|
* If `media` is an ISO9660 image/device, this function retrieves the expected
|
|
* application ID.
|
|
*
|
|
* Note: In practice, this will usually not be the exact copy of the application
|
|
* ID string on the ISO image/device but rather a regular expression that
|
|
* matches it.
|
|
* @returns the application id, or NULL
|
|
*/
|
|
get_application_id(): string;
|
|
/**
|
|
* Retrieves the target hardware architecture of the OS `media` provides.
|
|
* @returns the hardware architecture, or NULL
|
|
*/
|
|
get_architecture(): string;
|
|
/**
|
|
* Whether `media` should ejected after the installation procces.
|
|
* @returns #TRUE if media should be ejected, #FALSE otherwise
|
|
*/
|
|
get_eject_after_install(): boolean;
|
|
/**
|
|
* Retrieves the path to the initrd image in the install tree.
|
|
*
|
|
* Note: This only applies to installer medias of 'linux' OS family.
|
|
* @returns the path to initrd image, or NULL
|
|
*/
|
|
get_initrd_path(): string;
|
|
get_install_script_list(): InstallScriptList;
|
|
/**
|
|
* Whether `media` provides an installer for an OS.
|
|
* @returns #TRUE if media is installer, #FALSE otherwise
|
|
*/
|
|
get_installer(): boolean;
|
|
/**
|
|
* If media is an installer, this method retrieves the number of reboots the
|
|
* installer takes before installation is complete.
|
|
*
|
|
* This function is not supposed to be called on media that has no installer.
|
|
* You can use #osinfo_media_get_installer(or OsinfoMedia::installer) to check
|
|
* that.
|
|
*
|
|
* Warning: Some media allow you to install from live sessions, in which case
|
|
* number of reboots *alone* is not a reliable method for tracking installation.
|
|
* @returns the number of installer reboots or -1 if media is not an installer
|
|
*/
|
|
get_installer_reboots(): number;
|
|
/**
|
|
* Retrieves the path to the kernel image in the install tree.
|
|
*
|
|
* Note: This only applies to installer medias of 'linux' OS family.
|
|
* @returns the path to kernel image, or NULL
|
|
*/
|
|
get_kernel_path(): string;
|
|
/**
|
|
* If media is an installer, this property indicates the languages that
|
|
* can be used during automatic installations.
|
|
*
|
|
* On media that are not installers, this property will indicate the
|
|
* languages that the user interface can be displayed in.
|
|
* Use #osinfo_media_get_installer(or OsinfoMedia::installer) to know
|
|
* if the media is an installer or not.
|
|
* @returns a #GList containing the list of the UI languages this media supports. The list must be freed with g_list_free() when no longer needed. If the supported languages are unknown, NULL will be returned.
|
|
*/
|
|
get_languages(): string[];
|
|
/**
|
|
* Whether `media` can boot directly an OS without any installations.
|
|
* @returns #TRUE if media is live, #FALSE otherwise
|
|
*/
|
|
get_live(): boolean;
|
|
get_os(): Os;
|
|
/**
|
|
* Gets the variants of the associated operating system.
|
|
* @returns the operating system variant, or NULL
|
|
*/
|
|
get_os_variants(): OsVariantList;
|
|
/**
|
|
* If `media` is an ISO9660 image/device, this function retrieves the expected
|
|
* publisher ID.
|
|
*
|
|
* Note: In practice, this will usually not be the exact copy of the publisher
|
|
* ID string on the ISO image/device but rather a regular expression that
|
|
* matches it.
|
|
* @returns the publisher id, or NULL
|
|
*/
|
|
get_publisher_id(): string;
|
|
/**
|
|
* If `media` is an ISO9660 image/device, this function retrieves the expected
|
|
* system ID.
|
|
*
|
|
* Note: In practice, this will usually not be the exact copy of the system ID
|
|
* string on the ISO image/device but rather a regular expression that matches
|
|
* it.
|
|
* @returns the system id, or NULL
|
|
*/
|
|
get_system_id(): string;
|
|
/**
|
|
* The URL to the `media`
|
|
* @returns the URL, or NULL
|
|
*/
|
|
get_url(): string;
|
|
/**
|
|
* If `media` is an ISO9660 image/device, this function retrieves the expected
|
|
* volume ID.
|
|
*
|
|
* Note: In practice, this will usually not be the exact copy of the volume ID
|
|
* string on the ISO image/device but rather a regular expression that matches
|
|
* it.
|
|
* @returns the volume id, or NULL
|
|
*/
|
|
get_volume_id(): string;
|
|
get_volume_size(): number;
|
|
is_bootable(): boolean;
|
|
/**
|
|
* Determines whether the metadata for the unidentified `media` is a match
|
|
* for the `reference` media.
|
|
*
|
|
* The metadata in the unidentified `media` must be literal strings,
|
|
* while the metadata in the `reference` media must be regular expressions.
|
|
* @param reference a reference #OsinfoMedia instance
|
|
* @returns #TRUE if @media is a match for @reference. #FALSE otherwise
|
|
*/
|
|
matches(reference: Media): boolean;
|
|
/**
|
|
* Whether `media` supports installation using install scripts.
|
|
* @returns #TRUE if install-scripts are supported by the media, #FALSE otherwise
|
|
*/
|
|
supports_installer_script(): boolean;
|
|
}
|
|
|
|
module MediaList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class MediaList extends List {
|
|
static $gtype: GObject.GType<MediaList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<MediaList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): MediaList;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Construct a new media list that is filled with medias
|
|
* from `source`
|
|
* @returns a copy of the media list
|
|
*/
|
|
new_copy(): MediaList;
|
|
/**
|
|
* Construct a new media list that is filled with medias
|
|
* from `source` that match `filter`
|
|
* @param filter the filter to apply
|
|
* @returns a filtered copy of the media list
|
|
*/
|
|
new_filtered(filter: Filter): MediaList;
|
|
/**
|
|
* Construct a new media list that is filled with only the
|
|
* medias that are present in both `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second media list to copy
|
|
* @returns an intersection of the two media lists
|
|
*/
|
|
new_intersection(sourceTwo: MediaList): MediaList;
|
|
/**
|
|
* Construct a new media list that is filled with all the
|
|
* medias that are present in either `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second media list to copy
|
|
* @returns a union of the two media lists
|
|
*/
|
|
new_union(sourceTwo: MediaList): MediaList;
|
|
}
|
|
|
|
module Os {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Product.ConstructorProps {
|
|
cloud_image_username: string;
|
|
cloudImageUsername: string;
|
|
distro: string;
|
|
family: string;
|
|
kernel_url_argument: string;
|
|
kernelUrlArgument: string;
|
|
}
|
|
}
|
|
|
|
class Os extends Product {
|
|
static $gtype: GObject.GType<Os>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The username to be passed to the cloud-init program.
|
|
*/
|
|
get cloud_image_username(): string;
|
|
/**
|
|
* The username to be passed to the cloud-init program.
|
|
*/
|
|
get cloudImageUsername(): string;
|
|
/**
|
|
* The generic distro this OS belongs to, for example fedora, windows,
|
|
* solaris, freebsd etc.
|
|
*/
|
|
get distro(): string;
|
|
/**
|
|
* The generic family this OS belongs to, based upon its kernel,
|
|
* for example linux, winnt, solaris, freebsd etc.
|
|
*/
|
|
get family(): string;
|
|
/**
|
|
* The argument to be passed to kernel command line when performing a
|
|
* tree based installation of this OS.
|
|
*/
|
|
get kernel_url_argument(): string;
|
|
/**
|
|
* The argument to be passed to kernel command line when performing a
|
|
* tree based installation of this OS.
|
|
*/
|
|
get kernelUrlArgument(): string;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Os.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string): Os;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Associated a device with an operating system. The
|
|
* returned #OsinfoDeviceLink can be used to record
|
|
* extra metadata against the link
|
|
* @param dev the device to associate with
|
|
* @returns the device association
|
|
*/
|
|
add_device(dev: Device): DeviceLink;
|
|
/**
|
|
* Adds `driver` to the list of device drivers of operating system `os`.
|
|
* @param driver the device driver to add
|
|
*/
|
|
add_device_driver(driver: DeviceDriver): void;
|
|
/**
|
|
* Adds `firmware` to the list of firmwares of operating system `os`.
|
|
* @param firmware the firmware to add
|
|
*/
|
|
add_firmware(firmware: Firmware): void;
|
|
/**
|
|
* Adds an installed image `image` to operating system `os`.
|
|
* @param image the image to add
|
|
*/
|
|
add_image(image: Image): void;
|
|
/**
|
|
* Adds `script` to the list of scripts of operating system `os`.
|
|
* @param script the install script to add
|
|
*/
|
|
add_install_script(script: InstallScript): void;
|
|
/**
|
|
* Adds `resources` to list of maximum resources of operating system `os`.
|
|
* @param resources the resources to add
|
|
*/
|
|
add_maximum_resources(resources: Resources): void;
|
|
/**
|
|
* Adds installation media `media` to operating system `os`.
|
|
* @param media the media to add
|
|
*/
|
|
add_media(media: Media): void;
|
|
/**
|
|
* Adds `resources` to list of minimum resources of operating system `os`.
|
|
* @param resources the resources to add
|
|
*/
|
|
add_minimum_resources(resources: Resources): void;
|
|
/**
|
|
* Adds `resources` to list of resources needed for network installing an
|
|
* operating system `os`.
|
|
* @param resources the resources to add
|
|
*/
|
|
add_network_install_resources(resources: Resources): void;
|
|
/**
|
|
* Adds `resources` to list of recommended resources of operating system `os`.
|
|
* @param resources the resources to add
|
|
*/
|
|
add_recommended_resources(resources: Resources): void;
|
|
/**
|
|
* Adds installation tree `tree` to operating system `os`.
|
|
* @param tree the tree to add
|
|
*/
|
|
add_tree(tree: Tree): void;
|
|
/**
|
|
* Adds a variant `variant` to operating system `os`.
|
|
* @param variant the variant to add
|
|
*/
|
|
add_variant(variant: OsVariant): void;
|
|
find_install_script(profile: string): InstallScript;
|
|
/**
|
|
* Get all devicelinks matching a given filter but unlike
|
|
* osinfo_os_get_device_links this function also retrieves devices from all
|
|
* derived and cloned operating systems.
|
|
* @param filter an optional device property filter
|
|
* @returns A list of OsinfoDeviceLink
|
|
*/
|
|
get_all_device_links(filter?: Filter | null): DeviceLinkList;
|
|
/**
|
|
* Get all devices matching a given filter but unlike osinfo_os_get_devices
|
|
* this function also retrieves devices from all derived and cloned operating
|
|
* systems.
|
|
* @param filter an optional device property filter
|
|
* @returns A list of devices
|
|
*/
|
|
get_all_devices(filter?: Filter | null): DeviceList;
|
|
/**
|
|
* Gets the username expected to be passed to the cloud image when performing
|
|
* installation.
|
|
* @returns the username, if present. Otherwise, NULL.
|
|
*/
|
|
get_cloud_image_username(): string;
|
|
/**
|
|
* Get the complete firmwares matching a given filter, including the non-supported ones.
|
|
* @param filter an optional firmware property filter
|
|
* @returns A list of firmwares
|
|
*/
|
|
get_complete_firmware_list(filter?: Filter | null): FirmwareList;
|
|
/**
|
|
* Gets list of all available device drivers for OS `os`.
|
|
* @returns A list of device drivers
|
|
*/
|
|
get_device_drivers(): DeviceDriverList;
|
|
/**
|
|
* Gets list of the highest priority device drivers for OS `os`.
|
|
* @returns A list of device drivers
|
|
*/
|
|
get_device_drivers_prioritized(): DeviceDriverList;
|
|
/**
|
|
* Get all devices matching a given filter. The filter
|
|
* matches against the links, not the devices.
|
|
* @param filter an optional device property filter
|
|
* @returns A list of device links
|
|
*/
|
|
get_device_links(filter?: Filter | null): DeviceLinkList;
|
|
/**
|
|
* Get all devices matching a given filter
|
|
* @param filter an optional device property filter
|
|
* @returns A list of devices
|
|
*/
|
|
get_devices(filter?: Filter | null): DeviceList;
|
|
/**
|
|
* A utility function that gets devices found from the list of devices
|
|
* `os` supports, for which the value of `property` is `value`.
|
|
* @param property the property of interest
|
|
* @param value the required value of property @property
|
|
* @param inherited Should devices from inherited and cloned OSs be included in the search.
|
|
* @returns The found devices
|
|
*/
|
|
get_devices_by_property(property: string, value: string, inherited: boolean): DeviceList;
|
|
/**
|
|
* Retrieves the generic family the OS `os` belongs to, for example fedora,
|
|
* ubuntu, windows, solaris, freebsd etc.
|
|
* @returns the distro of this os
|
|
*/
|
|
get_distro(): string;
|
|
/**
|
|
* Retrieves the generic family the OS `os` belongs to, based upon its kernel,
|
|
* for example linux, winnt, solaris, freebsd etc.
|
|
* @returns the family of this os
|
|
*/
|
|
get_family(): string;
|
|
/**
|
|
* Get all the supported firmwares matching a given filter
|
|
* @param filter an optional firmware property filter
|
|
* @returns A list of firmwares
|
|
*/
|
|
get_firmware_list(filter?: Filter | null): FirmwareList;
|
|
/**
|
|
* Get all installed images associated with operating system `os`.
|
|
* @returns A list of images
|
|
*/
|
|
get_image_list(): ImageList;
|
|
get_install_script_list(): InstallScriptList;
|
|
/**
|
|
* Gets the argument expected to be passed to the kernel command line when
|
|
* performing a tree based installation.
|
|
* @returns the kernel url argument, if present. Otherwise, NULL.
|
|
*/
|
|
get_kernel_url_argument(): string;
|
|
/**
|
|
* Get the list of maximum resources for the operating system `os`.
|
|
* @returns A list of resources
|
|
*/
|
|
get_maximum_resources(): ResourcesList;
|
|
/**
|
|
* Get all installation medias associated with operating system `os`.
|
|
* @returns A list of medias
|
|
*/
|
|
get_media_list(): MediaList;
|
|
/**
|
|
* Get the list of minimum required resources for the operating system `os`.
|
|
* @returns A list of resources
|
|
*/
|
|
get_minimum_resources(): ResourcesList;
|
|
/**
|
|
* Get the list of resources needed for network installing an operating system
|
|
* `os`.
|
|
* @returns A list of resources
|
|
*/
|
|
get_network_install_resources(): ResourcesList;
|
|
/**
|
|
* Get the list of recommended resources for the operating system `os`.
|
|
* @returns A list of resources
|
|
*/
|
|
get_recommended_resources(): ResourcesList;
|
|
/**
|
|
* Use this to determine the release status of the `os`.
|
|
* @returns release status of @os.
|
|
*/
|
|
get_release_status(): ReleaseStatus;
|
|
/**
|
|
* Get all installation trees associated with operating system `os`.
|
|
* @returns A list of trees
|
|
*/
|
|
get_tree_list(): TreeList;
|
|
/**
|
|
* Gets all known variants of operating system `os`.
|
|
* @returns A list of variants
|
|
*/
|
|
get_variant_list(): OsVariantList;
|
|
}
|
|
|
|
module OsList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends ProductList.ConstructorProps {}
|
|
}
|
|
|
|
class OsList extends ProductList {
|
|
static $gtype: GObject.GType<OsList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<OsList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): OsList;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Construct a new os list that is filled with oss
|
|
* from `source`
|
|
* @returns a copy of the os list
|
|
*/
|
|
new_copy(): OsList;
|
|
/**
|
|
* Construct a new os list that is filled with oss
|
|
* from `source` that match `filter`
|
|
* @param filter the filter to apply
|
|
* @returns a filtered copy of the os list
|
|
*/
|
|
new_filtered(filter: Filter): OsList;
|
|
/**
|
|
* Construct a new os list that is filled with only the
|
|
* oss that are present in both `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second os list to copy
|
|
* @returns an intersection of the two os lists
|
|
*/
|
|
new_intersection(sourceTwo: OsList): OsList;
|
|
/**
|
|
* Construct a new os list that is filled with all the
|
|
* oss that are present in either `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second os list to copy
|
|
* @returns a union of the two os lists
|
|
*/
|
|
new_union(sourceTwo: OsList): OsList;
|
|
}
|
|
|
|
module OsVariant {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
name: string;
|
|
}
|
|
}
|
|
|
|
class OsVariant extends Entity {
|
|
static $gtype: GObject.GType<OsVariant>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The name to this variant.
|
|
*/
|
|
get name(): string;
|
|
set name(val: string);
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<OsVariant.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string): OsVariant;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* The name of the `variant`
|
|
* @returns the name, or NULL
|
|
*/
|
|
get_name(): string;
|
|
}
|
|
|
|
module OsVariantList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class OsVariantList extends List {
|
|
static $gtype: GObject.GType<OsVariantList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<OsVariantList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): OsVariantList;
|
|
}
|
|
|
|
module Platform {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Product.ConstructorProps {}
|
|
}
|
|
|
|
class Platform extends Product {
|
|
static $gtype: GObject.GType<Platform>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Platform.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string): Platform;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Associate a device with a platform. The returned #OsinfoDeviceLink
|
|
* can be used to record extra metadata against the link
|
|
* @param dev the device to associate
|
|
* @returns the device association
|
|
*/
|
|
add_device(dev: Device): DeviceLink;
|
|
/**
|
|
* Get all platforms matching a given filter but unlike
|
|
* osinfo_platform_get_devices this function also retrieves devices from
|
|
* all derived and upgraded platforms.
|
|
* @param filter an optional device property filter
|
|
* @returns A list of devices
|
|
*/
|
|
get_all_devices(filter?: Filter | null): DeviceList;
|
|
/**
|
|
* Retrieve all the associated devices matching the filter.
|
|
* The filter matches against the link, not the device.
|
|
* @param filter an optional filter
|
|
* @returns a list of #OsinfoDevice entities
|
|
*/
|
|
get_device_links(filter?: Filter | null): DeviceLinkList;
|
|
/**
|
|
* Retrieve all the associated devices matching the filter.
|
|
* The filter matches against the device, not the link.
|
|
* @param filter an optional filter
|
|
* @returns a list of #OsinfoDevice entities
|
|
*/
|
|
get_devices(filter?: Filter | null): DeviceList;
|
|
}
|
|
|
|
module PlatformList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends ProductList.ConstructorProps {}
|
|
}
|
|
|
|
class PlatformList extends ProductList {
|
|
static $gtype: GObject.GType<PlatformList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<PlatformList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): PlatformList;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Construct a new platform list that is filled with platforms
|
|
* from `source`
|
|
* @returns a copy of the platform list
|
|
*/
|
|
new_copy(): PlatformList;
|
|
/**
|
|
* Construct a new platform list that is filled with platforms
|
|
* from `source` that match `filter`
|
|
* @param filter the filter to apply
|
|
* @returns a filtered copy of the platform list
|
|
*/
|
|
new_filtered(filter: Filter): PlatformList;
|
|
/**
|
|
* Construct a new platform list that is filled with only the
|
|
* platforms that are present in both `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second platform list to copy
|
|
* @returns an intersection of the two platform lists
|
|
*/
|
|
new_intersection(sourceTwo: PlatformList): PlatformList;
|
|
/**
|
|
* Construct a new platform list that is filled with all the
|
|
* platforms that are present in either `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second platform list to copy
|
|
* @returns a union of the two platform lists
|
|
*/
|
|
new_union(sourceTwo: PlatformList): PlatformList;
|
|
}
|
|
|
|
module Product {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
codename: string;
|
|
logo: string;
|
|
name: string;
|
|
short_id: string;
|
|
shortId: string;
|
|
vendor: string;
|
|
version: string;
|
|
}
|
|
}
|
|
|
|
abstract class Product extends Entity {
|
|
static $gtype: GObject.GType<Product>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The codename of this product.
|
|
*/
|
|
get codename(): string;
|
|
/**
|
|
* The URI of the logo of the product.
|
|
*/
|
|
get logo(): string;
|
|
/**
|
|
* The name of this product.
|
|
*/
|
|
get name(): string;
|
|
/**
|
|
* The short ID of this product.
|
|
*/
|
|
get short_id(): string;
|
|
/**
|
|
* The short ID of this product.
|
|
*/
|
|
get shortId(): string;
|
|
/**
|
|
* The Vendor of this product.
|
|
*/
|
|
get vendor(): string;
|
|
/**
|
|
* The version of the product.
|
|
*/
|
|
get version(): string;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Product.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Add an association between two products
|
|
* @param relshp the relationship
|
|
* @param otherproduct the product to relate to
|
|
*/
|
|
add_related(relshp: ProductRelationship | null, otherproduct: Product): void;
|
|
get_codename(): string;
|
|
get_eol_date(): GLib.Date;
|
|
get_eol_date_string(): string;
|
|
get_logo(): string;
|
|
get_name(): string;
|
|
/**
|
|
* Get a list of products satisfying the requested
|
|
* relationship
|
|
* @param relshp the relationship to query
|
|
* @returns a list of related products
|
|
*/
|
|
get_related(relshp: ProductRelationship | null): ProductList;
|
|
get_release_date(): GLib.Date;
|
|
get_release_date_string(): string;
|
|
get_short_id(): string;
|
|
/**
|
|
* Retrieve all the short-ids associated with the product.
|
|
* @returns the list of short-ids.
|
|
*/
|
|
get_short_id_list(): string[];
|
|
get_vendor(): string;
|
|
get_version(): string;
|
|
}
|
|
|
|
module ProductFilter {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Filter.ConstructorProps {}
|
|
}
|
|
|
|
class ProductFilter extends Filter {
|
|
static $gtype: GObject.GType<ProductFilter>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<ProductFilter.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): ProductFilter;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Adds a constraint that matches products which
|
|
* have a relationship `relshp` with `product`. Multiple constraints
|
|
* can be set for the same `relshp` or `product,` in which case
|
|
* all must match
|
|
* @param relshp the relationship to filter on
|
|
* @param product the target product to filter on
|
|
*/
|
|
add_product_constraint(relshp: ProductRelationship | null, product: Product): number;
|
|
add_support_date_constraint(when: GLib.Date): void;
|
|
/**
|
|
* Remove all constraints for the relationship `relshp`
|
|
* @param relshp the relationship to clear
|
|
*/
|
|
clear_product_constraint(relshp: ProductRelationship | null): void;
|
|
/**
|
|
* Remove all relationship constraints
|
|
*/
|
|
clear_product_constraints(): void;
|
|
/**
|
|
* Retrieve a list of all operating systems that are
|
|
* the target of constraint for the relationship
|
|
* `relshp`.
|
|
* @param relshp a relationship to query
|
|
* @returns a list of operating systems
|
|
*/
|
|
get_product_constraint_values(relshp: ProductRelationship | null): Product[];
|
|
}
|
|
|
|
module ProductList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class ProductList extends List {
|
|
static $gtype: GObject.GType<ProductList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<ProductList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): ProductList;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Construct a new os list that is filled with oss
|
|
* from `source`
|
|
* @returns a copy of the os list
|
|
*/
|
|
new_copy(): ProductList;
|
|
/**
|
|
* Construct a new os list that is filled with oss
|
|
* from `source` that match `filter`
|
|
* @param filter the filter to apply
|
|
* @returns a filtered copy of the os list
|
|
*/
|
|
new_filtered(filter: Filter): ProductList;
|
|
/**
|
|
* Construct a new os list that is filled with only the
|
|
* oss that are present in both `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second os list to copy
|
|
* @returns an intersection of the two os lists
|
|
*/
|
|
new_intersection(sourceTwo: ProductList): ProductList;
|
|
/**
|
|
* Construct a new os list that is filled with all the
|
|
* oss that are present in either `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second os list to copy
|
|
* @returns a union of the two os lists
|
|
*/
|
|
new_union(sourceTwo: ProductList): ProductList;
|
|
}
|
|
|
|
module Resources {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
architecture: string;
|
|
cpu: number;
|
|
n_cpus: number;
|
|
nCpus: number;
|
|
ram: number;
|
|
storage: number;
|
|
}
|
|
}
|
|
|
|
class Resources extends Entity {
|
|
static $gtype: GObject.GType<Resources>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The target hardware architecture to which these resources applies.
|
|
*/
|
|
get architecture(): string;
|
|
/**
|
|
* The CPU frequency in hertz (Hz).
|
|
*/
|
|
get cpu(): number;
|
|
set cpu(val: number);
|
|
/**
|
|
* The number of CPUs.
|
|
*/
|
|
get n_cpus(): number;
|
|
set n_cpus(val: number);
|
|
/**
|
|
* The number of CPUs.
|
|
*/
|
|
get nCpus(): number;
|
|
set nCpus(val: number);
|
|
/**
|
|
* The amount of Random Access Memory (RAM) in bytes.
|
|
*/
|
|
get ram(): number;
|
|
set ram(val: number);
|
|
/**
|
|
* The amount of storage space in bytes.
|
|
*/
|
|
get storage(): number;
|
|
set storage(val: number);
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Resources.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string, architecture: string): Resources;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Retrieves the target hardware architecture to which `resources` applies. Some
|
|
* operating systems specify the same requirements and recommendations for all
|
|
* architectures. In such cases, the string returned by this call will be
|
|
* #OSINFO_ARCHITECTURE_ALL.
|
|
* @returns the hardware architecture.
|
|
*/
|
|
get_architecture(): string;
|
|
/**
|
|
* Retrieves the CPU frequency in hertz (Hz). Divide the value by #OSINFO_MEGAHERTZ if
|
|
* you need this value in megahertz (MHz).
|
|
* @returns the CPU frequency, or -1.
|
|
*/
|
|
get_cpu(): number;
|
|
/**
|
|
* Retrieves the number of CPUs.
|
|
* @returns the number of CPUs, or -1.
|
|
*/
|
|
get_n_cpus(): number;
|
|
/**
|
|
* Retrieves the amount of Random Access Memory (RAM) in bytes. Divide the value
|
|
* by #OSINFO_MEBIBYTES if you need this value in mebibytes.
|
|
* @returns the amount of RAM, or -1.
|
|
*/
|
|
get_ram(): number;
|
|
/**
|
|
* Retrieves the amount of storage space in bytes. Divide the value by
|
|
* #OSINFO_GIBIBYTES if you need this value in gibibytes.
|
|
* @returns the amount of storage, or -1.
|
|
*/
|
|
get_storage(): number;
|
|
/**
|
|
* Sets the CPU frequency.
|
|
* @param cpu the CPU frequency in hertz (Hz)
|
|
*/
|
|
set_cpu(cpu: number): void;
|
|
/**
|
|
* Sets the number of CPUs.
|
|
* @param n_cpus the number of CPUs
|
|
*/
|
|
set_n_cpus(n_cpus: number): void;
|
|
/**
|
|
* Sets the amount of RAM in bytes.
|
|
* @param ram the amount of ram in bytes
|
|
*/
|
|
set_ram(ram: number): void;
|
|
/**
|
|
* Sets the amount of storage space.
|
|
* @param storage the amount of storage in bytes
|
|
*/
|
|
set_storage(storage: number): void;
|
|
}
|
|
|
|
module ResourcesList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class ResourcesList extends List {
|
|
static $gtype: GObject.GType<ResourcesList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<ResourcesList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): ResourcesList;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Construct a new resources list that is filled with resources instances
|
|
* from `source`
|
|
* @returns a copy of the resources list
|
|
*/
|
|
new_copy(): ResourcesList;
|
|
/**
|
|
* Construct a new resources list that is filled with resources instances
|
|
* from `source` that match `filter`
|
|
* @param filter the filter to apply
|
|
* @returns a filtered copy of the resources list
|
|
*/
|
|
new_filtered(filter: Filter): ResourcesList;
|
|
/**
|
|
* Construct a new resources list that is filled with only the
|
|
* resources instances that are present in both `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second resources list to copy
|
|
* @returns an intersection of the two resources lists
|
|
*/
|
|
new_intersection(sourceTwo: ResourcesList): ResourcesList;
|
|
/**
|
|
* Construct a new resources list that is filled with all the
|
|
* resources instances that are present in either `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second resources list to copy
|
|
* @returns a union of the two resources lists
|
|
*/
|
|
new_union(sourceTwo: ResourcesList): ResourcesList;
|
|
}
|
|
|
|
module Tree {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends Entity.ConstructorProps {
|
|
architecture: string;
|
|
boot_iso_path: string;
|
|
bootIsoPath: string;
|
|
has_treeinfo: boolean;
|
|
hasTreeinfo: boolean;
|
|
initrd_path: string;
|
|
initrdPath: string;
|
|
kernel_path: string;
|
|
kernelPath: string;
|
|
os: Os;
|
|
treeinfo_arch: string;
|
|
treeinfoArch: string;
|
|
treeinfo_family: string;
|
|
treeinfoFamily: string;
|
|
treeinfo_variant: string;
|
|
treeinfoVariant: string;
|
|
treeinfo_version: string;
|
|
treeinfoVersion: string;
|
|
url: string;
|
|
}
|
|
}
|
|
|
|
class Tree extends Entity {
|
|
static $gtype: GObject.GType<Tree>;
|
|
|
|
// Properties
|
|
|
|
/**
|
|
* The target hardware architecture of this tree.
|
|
*/
|
|
get architecture(): string;
|
|
set architecture(val: string);
|
|
/**
|
|
* The path to the boot ISO in the install tree
|
|
*/
|
|
get boot_iso_path(): string;
|
|
set boot_iso_path(val: string);
|
|
/**
|
|
* The path to the boot ISO in the install tree
|
|
*/
|
|
get bootIsoPath(): string;
|
|
set bootIsoPath(val: string);
|
|
/**
|
|
* Whether the tree has treeinfo or not
|
|
*/
|
|
get has_treeinfo(): boolean;
|
|
set has_treeinfo(val: boolean);
|
|
/**
|
|
* Whether the tree has treeinfo or not
|
|
*/
|
|
get hasTreeinfo(): boolean;
|
|
set hasTreeinfo(val: boolean);
|
|
/**
|
|
* The path to the initrd image in the install tree.
|
|
*/
|
|
get initrd_path(): string;
|
|
set initrd_path(val: string);
|
|
/**
|
|
* The path to the initrd image in the install tree.
|
|
*/
|
|
get initrdPath(): string;
|
|
set initrdPath(val: string);
|
|
/**
|
|
* The path to the kernel image in the install tree.
|
|
*/
|
|
get kernel_path(): string;
|
|
set kernel_path(val: string);
|
|
/**
|
|
* The path to the kernel image in the install tree.
|
|
*/
|
|
get kernelPath(): string;
|
|
set kernelPath(val: string);
|
|
/**
|
|
* Os information for the current tree. For tree stored in an
|
|
* #OsinfoDb, it will be filled when the database is loaded, otherwise
|
|
* the property will be filled after a successful call to
|
|
* osinfo_db_identify_tree().
|
|
*/
|
|
get os(): Os;
|
|
set os(val: Os);
|
|
/**
|
|
* The treeinfo arch
|
|
*/
|
|
get treeinfo_arch(): string;
|
|
set treeinfo_arch(val: string);
|
|
/**
|
|
* The treeinfo arch
|
|
*/
|
|
get treeinfoArch(): string;
|
|
set treeinfoArch(val: string);
|
|
/**
|
|
* The treeinfo family
|
|
*/
|
|
get treeinfo_family(): string;
|
|
set treeinfo_family(val: string);
|
|
/**
|
|
* The treeinfo family
|
|
*/
|
|
get treeinfoFamily(): string;
|
|
set treeinfoFamily(val: string);
|
|
/**
|
|
* The treeinfo variant
|
|
*/
|
|
get treeinfo_variant(): string;
|
|
set treeinfo_variant(val: string);
|
|
/**
|
|
* The treeinfo variant
|
|
*/
|
|
get treeinfoVariant(): string;
|
|
set treeinfoVariant(val: string);
|
|
/**
|
|
* The treeinfo version
|
|
*/
|
|
get treeinfo_version(): string;
|
|
set treeinfo_version(val: string);
|
|
/**
|
|
* The treeinfo version
|
|
*/
|
|
get treeinfoVersion(): string;
|
|
set treeinfoVersion(val: string);
|
|
/**
|
|
* The URL to this tree.
|
|
*/
|
|
get url(): string;
|
|
set url(val: string);
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<Tree.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](id: string, architecture: string): Tree;
|
|
|
|
// Static methods
|
|
|
|
/**
|
|
* Creates a new #OsinfoTree for installation tree at `location`. The `location`
|
|
* could be a http:// or a https:// URI, or a local file.
|
|
*
|
|
* NOTE: Currently this only works for trees with a .treeinfo file
|
|
* @param location the location of an installation tree
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
*/
|
|
static create_from_location(location: string, cancellable?: Gio.Cancellable | null): Tree;
|
|
/**
|
|
* Asynchronous variant of #osinfo_tree_create_from_location.
|
|
* @param location the location of an installation tree
|
|
* @param priority the I/O priority of the request
|
|
* @param cancellable a #GCancellable, or %NULL
|
|
* @param callback Function to call when result of this call is ready
|
|
*/
|
|
static create_from_location_async(
|
|
location: string,
|
|
priority: number,
|
|
cancellable?: Gio.Cancellable | null,
|
|
callback?: Gio.AsyncReadyCallback<Tree> | null,
|
|
): void;
|
|
/**
|
|
* Finishes an asynchronous tree object creation process started with
|
|
* #osinfo_tree_create_from_location_async.
|
|
* @param res a #GAsyncResult
|
|
*/
|
|
static create_from_location_finish(res: Gio.AsyncResult): Tree;
|
|
/**
|
|
* Creates a new #OsinfoTree for installation tree represented by `treeinfo`.
|
|
* @param treeinfo a string representing the .treeinfo content
|
|
* @param location the location of the original @treeinfo
|
|
*/
|
|
static create_from_treeinfo(treeinfo: string, location: string): Tree;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Retrieves the target hardware architecture of the OS `tree` provides.
|
|
* @returns the hardware architecture, or NULL
|
|
*/
|
|
get_architecture(): string;
|
|
/**
|
|
* Retrieves the path to the boot_iso image in the install tree.
|
|
* @returns the path to boot_iso image, or NULL
|
|
*/
|
|
get_boot_iso_path(): string;
|
|
/**
|
|
* Retrieves the path to the initrd image in the install tree.
|
|
*
|
|
* Note: This only applies to installer trees of 'linux' OS family.
|
|
* @returns the path to initrd image, or NULL
|
|
*/
|
|
get_initrd_path(): string;
|
|
/**
|
|
* Retrieves the path to the kernel image in the install tree.
|
|
*
|
|
* Note: This only applies to installer trees of 'linux' OS family.
|
|
* @returns the path to kernel image, or NULL
|
|
*/
|
|
get_kernel_path(): string;
|
|
get_os(): Os;
|
|
/**
|
|
* Gets the variants of the associated operating system.
|
|
* @returns the operating system variant, or NULL
|
|
*/
|
|
get_os_variants(): OsVariantList;
|
|
/**
|
|
* If `tree` has treeinfo, this function retrieves the expected architecture.
|
|
*
|
|
* Note: In practice, this will usually not be the exact copy of the
|
|
* architecture but rather a regular expression that matches it.
|
|
* @returns the treeinfo architecture, or NULL
|
|
*/
|
|
get_treeinfo_arch(): string;
|
|
/**
|
|
* If `tree` has treeinfo, this function retrieves the expected family.
|
|
*
|
|
* Note: In practice, this will usually not be the exact copy of the family
|
|
* but rather a regular expression that matches it.
|
|
* @returns the treeinfo family, or NULL
|
|
*/
|
|
get_treeinfo_family(): string;
|
|
/**
|
|
* If `tree` has treeinfo, this function retrieves the expected variant.
|
|
*
|
|
* Note: In practice, this will usually not be the exact copy of the variant
|
|
* but rather a regular expression that matches it.
|
|
* @returns the treeinfo variant, or NULL
|
|
*/
|
|
get_treeinfo_variant(): string;
|
|
/**
|
|
* If `tree` has treeinfo, this function retrieves the expected version.
|
|
*
|
|
* Note: In practice, this will usually not be the exact copy of version but
|
|
* rather a regular expression that matches it.
|
|
* @returns the treeinfo version, or NULL
|
|
*/
|
|
get_treeinfo_version(): string;
|
|
/**
|
|
* The URL to the `tree`
|
|
* @returns the URL, or NULL
|
|
*/
|
|
get_url(): string;
|
|
/**
|
|
* Determines whether the metadata for the unidentified `tree` is a match
|
|
* for the `reference` tree.
|
|
*
|
|
* The metadata in the unidentified `tree` must be literal strings,
|
|
* while the metadata in the `reference` tree must be regular expressions.
|
|
* @param reference a reference #OsinfoTree instance
|
|
* @returns #TRUE if @tree is a match for @reference. #FALSE otherwise
|
|
*/
|
|
matches(reference: Tree): boolean;
|
|
/**
|
|
* Sets the #OsinfoOs associated to the #OsinfoTree instance.
|
|
* @param os an #OsinfoOs instance
|
|
*/
|
|
set_os(os: Os): void;
|
|
}
|
|
|
|
module TreeList {
|
|
// Constructor properties interface
|
|
|
|
interface ConstructorProps extends List.ConstructorProps {}
|
|
}
|
|
|
|
class TreeList extends List {
|
|
static $gtype: GObject.GType<TreeList>;
|
|
|
|
// Constructors
|
|
|
|
constructor(properties?: Partial<TreeList.ConstructorProps>, ...args: any[]);
|
|
|
|
_init(...args: any[]): void;
|
|
|
|
static ['new'](): TreeList;
|
|
|
|
// Methods
|
|
|
|
/**
|
|
* Construct a new tree list that is filled with trees
|
|
* from `source`
|
|
* @returns a copy of the tree list
|
|
*/
|
|
new_copy(): TreeList;
|
|
/**
|
|
* Construct a new tree list that is filled with trees
|
|
* from `source` that match `filter`
|
|
* @param filter the filter to apply
|
|
* @returns a filtered copy of the tree list
|
|
*/
|
|
new_filtered(filter: Filter): TreeList;
|
|
/**
|
|
* Construct a new tree list that is filled with only the
|
|
* trees that are present in both `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second tree list to copy
|
|
* @returns an intersection of the two tree lists
|
|
*/
|
|
new_intersection(sourceTwo: TreeList): TreeList;
|
|
/**
|
|
* Construct a new tree list that is filled with all the
|
|
* trees that are present in either `sourceOne` and `sourceTwo`.
|
|
* @param sourceTwo the second tree list to copy
|
|
* @returns a union of the two tree lists
|
|
*/
|
|
new_union(sourceTwo: TreeList): TreeList;
|
|
}
|
|
|
|
type AvatarFormatClass = typeof AvatarFormat;
|
|
abstract class AvatarFormatPrivate {
|
|
static $gtype: GObject.GType<AvatarFormatPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type DatamapClass = typeof Datamap;
|
|
type DatamapListClass = typeof DatamapList;
|
|
abstract class DatamapListPrivate {
|
|
static $gtype: GObject.GType<DatamapListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class DatamapPrivate {
|
|
static $gtype: GObject.GType<DatamapPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type DbClass = typeof Db;
|
|
abstract class DbPrivate {
|
|
static $gtype: GObject.GType<DbPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type DeploymentClass = typeof Deployment;
|
|
type DeploymentListClass = typeof DeploymentList;
|
|
abstract class DeploymentListPrivate {
|
|
static $gtype: GObject.GType<DeploymentListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class DeploymentPrivate {
|
|
static $gtype: GObject.GType<DeploymentPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type DeviceClass = typeof Device;
|
|
type DeviceDriverClass = typeof DeviceDriver;
|
|
type DeviceDriverListClass = typeof DeviceDriverList;
|
|
abstract class DeviceDriverListPrivate {
|
|
static $gtype: GObject.GType<DeviceDriverListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class DeviceDriverPrivate {
|
|
static $gtype: GObject.GType<DeviceDriverPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type DeviceLinkClass = typeof DeviceLink;
|
|
type DeviceLinkFilterClass = typeof DeviceLinkFilter;
|
|
abstract class DeviceLinkFilterPrivate {
|
|
static $gtype: GObject.GType<DeviceLinkFilterPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type DeviceLinkListClass = typeof DeviceLinkList;
|
|
abstract class DeviceLinkListPrivate {
|
|
static $gtype: GObject.GType<DeviceLinkListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class DeviceLinkPrivate {
|
|
static $gtype: GObject.GType<DeviceLinkPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type DeviceListClass = typeof DeviceList;
|
|
abstract class DeviceListPrivate {
|
|
static $gtype: GObject.GType<DeviceListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class DevicePrivate {
|
|
static $gtype: GObject.GType<DevicePrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type EntityClass = typeof Entity;
|
|
abstract class EntityPrivate {
|
|
static $gtype: GObject.GType<EntityPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type FilterClass = typeof Filter;
|
|
abstract class FilterPrivate {
|
|
static $gtype: GObject.GType<FilterPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type FirmwareClass = typeof Firmware;
|
|
type FirmwareListClass = typeof FirmwareList;
|
|
abstract class FirmwareListPrivate {
|
|
static $gtype: GObject.GType<FirmwareListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class FirmwarePrivate {
|
|
static $gtype: GObject.GType<FirmwarePrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type ImageClass = typeof Image;
|
|
type ImageListClass = typeof ImageList;
|
|
abstract class ImageListPrivate {
|
|
static $gtype: GObject.GType<ImageListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class ImagePrivate {
|
|
static $gtype: GObject.GType<ImagePrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type InstallConfigClass = typeof InstallConfig;
|
|
type InstallConfigParamClass = typeof InstallConfigParam;
|
|
type InstallConfigParamListClass = typeof InstallConfigParamList;
|
|
abstract class InstallConfigParamListPrivate {
|
|
static $gtype: GObject.GType<InstallConfigParamListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class InstallConfigParamPrivate {
|
|
static $gtype: GObject.GType<InstallConfigParamPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class InstallConfigPrivate {
|
|
static $gtype: GObject.GType<InstallConfigPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type InstallScriptClass = typeof InstallScript;
|
|
type InstallScriptListClass = typeof InstallScriptList;
|
|
abstract class InstallScriptListPrivate {
|
|
static $gtype: GObject.GType<InstallScriptListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class InstallScriptPrivate {
|
|
static $gtype: GObject.GType<InstallScriptPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type ListClass = typeof List;
|
|
abstract class ListPrivate {
|
|
static $gtype: GObject.GType<ListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type LoaderClass = typeof Loader;
|
|
abstract class LoaderPrivate {
|
|
static $gtype: GObject.GType<LoaderPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type MediaClass = typeof Media;
|
|
type MediaListClass = typeof MediaList;
|
|
abstract class MediaListPrivate {
|
|
static $gtype: GObject.GType<MediaListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class MediaPrivate {
|
|
static $gtype: GObject.GType<MediaPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type OsClass = typeof Os;
|
|
type OsListClass = typeof OsList;
|
|
abstract class OsListPrivate {
|
|
static $gtype: GObject.GType<OsListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class OsPrivate {
|
|
static $gtype: GObject.GType<OsPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type OsVariantClass = typeof OsVariant;
|
|
type OsVariantListClass = typeof OsVariantList;
|
|
abstract class OsVariantListPrivate {
|
|
static $gtype: GObject.GType<OsVariantListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class OsVariantPrivate {
|
|
static $gtype: GObject.GType<OsVariantPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type PlatformClass = typeof Platform;
|
|
type PlatformListClass = typeof PlatformList;
|
|
abstract class PlatformListPrivate {
|
|
static $gtype: GObject.GType<PlatformListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class PlatformPrivate {
|
|
static $gtype: GObject.GType<PlatformPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type ProductClass = typeof Product;
|
|
type ProductFilterClass = typeof ProductFilter;
|
|
abstract class ProductFilterPrivate {
|
|
static $gtype: GObject.GType<ProductFilterPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type ProductListClass = typeof ProductList;
|
|
abstract class ProductListPrivate {
|
|
static $gtype: GObject.GType<ProductListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class ProductPrivate {
|
|
static $gtype: GObject.GType<ProductPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type ResourcesClass = typeof Resources;
|
|
type ResourcesListClass = typeof ResourcesList;
|
|
abstract class ResourcesListPrivate {
|
|
static $gtype: GObject.GType<ResourcesListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class ResourcesPrivate {
|
|
static $gtype: GObject.GType<ResourcesPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
type TreeClass = typeof Tree;
|
|
type TreeListClass = typeof TreeList;
|
|
abstract class TreeListPrivate {
|
|
static $gtype: GObject.GType<TreeListPrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
abstract class TreePrivate {
|
|
static $gtype: GObject.GType<TreePrivate>;
|
|
|
|
// Constructors
|
|
|
|
_init(...args: any[]): void;
|
|
}
|
|
|
|
/**
|
|
* Name of the imported GIR library
|
|
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
|
|
*/
|
|
const __name__: string;
|
|
/**
|
|
* Version of the imported GIR library
|
|
* `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
|
|
*/
|
|
const __version__: string;
|
|
}
|
|
|
|
export default Libosinfo;
|
|
}
|
|
|
|
declare module 'gi://Libosinfo' {
|
|
import Libosinfo10 from 'gi://Libosinfo?version=1.0';
|
|
export default Libosinfo10;
|
|
}
|
|
// END
|