objc2-virtualization 0.3.2

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
use objc2_foundation::*;

use crate::*;

extern_class!(
    /// Virtual machine configuration.
    ///
    /// VZVirtualMachineConfiguration defines the configuration of a VZVirtualMachine.
    ///
    /// The configuration of devices is often done in two parts:
    /// - Device configuration
    /// - Device attachment
    ///
    /// The device configuration defines the characteristics of the emulated hardware device.
    /// For example, for a network device, the device configuration defines the type of network adapter present
    /// in the virtual machine and its MAC address.
    ///
    /// The device attachment defines the host machine's resources that are exposed by the virtual device.
    /// For example, for a network device, the device attachment can be virtual network interface with a NAT
    /// to the real network.
    ///
    /// Creating a virtual machine using the Virtualization framework requires the app to have the "com.apple.security.virtualization" entitlement.
    /// A VZVirtualMachineConfiguration is considered invalid if the application does not have the entitlement.
    ///
    /// ## Configuring a virtual machine to run macOS
    ///
    /// To configure a virtual machine running macOS:
    /// - Set up a platform configuration of type VZMacPlatformConfiguration and set it on the `platform` property.
    /// - Set up a VZMacOSBootLoader on the `bootLoader` property.
    /// - Set the CPUCount and memorySize based on the guest's VZMacOSConfigurationRequirements.
    /// - Set up the main storage device as first device on `storageDevices`. Additional storage devices can be set up after the main storage.
    /// - Set up the `keyboards`, `pointingDevices` and `graphicsDevices` devices.
    /// - Set up any additional device as needed.
    ///
    /// ## Configuring a virtual machine to run Linux
    ///
    /// To configure a virtual machine running Linux:
    /// - Set up a VZLinuxBootLoader on the `bootLoader` property.
    /// - Set the CPUCount and memorySize.
    /// - Set up any additional device as needed.
    ///
    ///
    /// See: VZVirtualMachine
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/virtualization/vzvirtualmachineconfiguration?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct VZVirtualMachineConfiguration;
);

extern_conformance!(
    unsafe impl NSCopying for VZVirtualMachineConfiguration {}
);

unsafe impl CopyingHelper for VZVirtualMachineConfiguration {
    type Result = Self;
}

extern_conformance!(
    unsafe impl NSObjectProtocol for VZVirtualMachineConfiguration {}
);

impl VZVirtualMachineConfiguration {
    extern_methods!(
        #[cfg(feature = "VZBootLoader")]
        /// Boot loader used when the virtual machine starts.
        ///
        /// See: VZLinuxBootLoader
        ///
        /// See: VZMacOSBootLoader
        #[unsafe(method(bootLoader))]
        #[unsafe(method_family = none)]
        pub unsafe fn bootLoader(&self) -> Option<Retained<VZBootLoader>>;

        #[cfg(feature = "VZBootLoader")]
        /// Setter for [`bootLoader`][Self::bootLoader].
        #[unsafe(method(setBootLoader:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setBootLoader(&self, boot_loader: Option<&VZBootLoader>);

        /// Virtual machine memory size in bytes.
        ///
        /// The memory size must be a multiple of a 1 megabyte (1024 * 1024 bytes) between VZVirtualMachineConfiguration.minimumAllowedMemorySize
        /// and VZVirtualMachineConfiguration.maximumAllowedMemorySize.
        ///
        /// The memorySize represents the total physical memory seen by a guest OS running in the virtual machine.
        /// Not all memory is allocated on start, the virtual machine allocates memory on demand.
        ///
        /// See: VZVirtualMachineConfiguration.minimumAllowedMemorySize
        ///
        /// See: VZVirtualMachineConfiguration.maximumAllowedMemorySize
        #[unsafe(method(memorySize))]
        #[unsafe(method_family = none)]
        pub unsafe fn memorySize(&self) -> u64;

        /// Setter for [`memorySize`][Self::memorySize].
        #[unsafe(method(setMemorySize:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMemorySize(&self, memory_size: u64);

        /// Number of CPUs.
        ///
        /// The number of CPUs must be a value between VZVirtualMachineConfiguration.minimumAllowedCPUCount
        /// and VZVirtualMachineConfiguration.maximumAllowedCPUCount.
        ///
        ///
        /// See: VZVirtualMachineConfiguration.minimumAllowedCPUCount
        ///
        /// See: VZVirtualMachineConfiguration.maximumAllowedCPUCount
        #[unsafe(method(CPUCount))]
        #[unsafe(method_family = none)]
        pub unsafe fn CPUCount(&self) -> NSUInteger;

        /// Setter for [`CPUCount`][Self::CPUCount].
        #[unsafe(method(setCPUCount:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setCPUCount(&self, cpu_count: NSUInteger);

        #[cfg(feature = "VZPlatformConfiguration")]
        /// The hardware platform to use.
        ///
        /// Can be an instance of a VZGenericPlatformConfiguration or VZMacPlatformConfiguration. Defaults to VZGenericPlatformConfiguration.
        /// When restoring from saved state you must ensure your configuration matches that of the saved virtual machine.
        ///
        ///
        /// See: VZGenericPlatformConfiguration
        ///
        /// See: VZMacPlatformConfiguration
        #[unsafe(method(platform))]
        #[unsafe(method_family = none)]
        pub unsafe fn platform(&self) -> Retained<VZPlatformConfiguration>;

        #[cfg(feature = "VZPlatformConfiguration")]
        /// Setter for [`platform`][Self::platform].
        #[unsafe(method(setPlatform:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPlatform(&self, platform: &VZPlatformConfiguration);

        #[cfg(feature = "VZAudioDeviceConfiguration")]
        /// List of audio devices. Empty by default.
        ///
        /// See: VZVirtioSoundDeviceConfiguration
        #[unsafe(method(audioDevices))]
        #[unsafe(method_family = none)]
        pub unsafe fn audioDevices(&self) -> Retained<NSArray<VZAudioDeviceConfiguration>>;

        #[cfg(feature = "VZAudioDeviceConfiguration")]
        /// Setter for [`audioDevices`][Self::audioDevices].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setAudioDevices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setAudioDevices(&self, audio_devices: &NSArray<VZAudioDeviceConfiguration>);

        #[cfg(feature = "VZConsoleDeviceConfiguration")]
        /// List of console devices. Empty by default.
        ///
        /// See: VZVirtioConsoleDeviceConfiguration
        #[unsafe(method(consoleDevices))]
        #[unsafe(method_family = none)]
        pub unsafe fn consoleDevices(&self) -> Retained<NSArray<VZConsoleDeviceConfiguration>>;

        #[cfg(feature = "VZConsoleDeviceConfiguration")]
        /// Setter for [`consoleDevices`][Self::consoleDevices].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setConsoleDevices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setConsoleDevices(
            &self,
            console_devices: &NSArray<VZConsoleDeviceConfiguration>,
        );

        #[cfg(feature = "VZDirectorySharingDeviceConfiguration")]
        /// List of directory sharing devices. Empty by default.
        ///
        /// See: VZVirtioFileSystemDeviceConfiguration
        #[unsafe(method(directorySharingDevices))]
        #[unsafe(method_family = none)]
        pub unsafe fn directorySharingDevices(
            &self,
        ) -> Retained<NSArray<VZDirectorySharingDeviceConfiguration>>;

        #[cfg(feature = "VZDirectorySharingDeviceConfiguration")]
        /// Setter for [`directorySharingDevices`][Self::directorySharingDevices].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setDirectorySharingDevices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDirectorySharingDevices(
            &self,
            directory_sharing_devices: &NSArray<VZDirectorySharingDeviceConfiguration>,
        );

        #[cfg(feature = "VZEntropyDeviceConfiguration")]
        /// List of entropy devices. Empty by default.
        ///
        /// See: VZVirtioEntropyDeviceConfiguration
        #[unsafe(method(entropyDevices))]
        #[unsafe(method_family = none)]
        pub unsafe fn entropyDevices(&self) -> Retained<NSArray<VZEntropyDeviceConfiguration>>;

        #[cfg(feature = "VZEntropyDeviceConfiguration")]
        /// Setter for [`entropyDevices`][Self::entropyDevices].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setEntropyDevices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setEntropyDevices(
            &self,
            entropy_devices: &NSArray<VZEntropyDeviceConfiguration>,
        );

        #[cfg(feature = "VZMemoryBalloonDeviceConfiguration")]
        /// List of memory balloon devices. Empty by default.
        ///
        /// See: VZVirtioTraditionalMemoryBalloonDeviceConfiguration
        #[unsafe(method(memoryBalloonDevices))]
        #[unsafe(method_family = none)]
        pub unsafe fn memoryBalloonDevices(
            &self,
        ) -> Retained<NSArray<VZMemoryBalloonDeviceConfiguration>>;

        #[cfg(feature = "VZMemoryBalloonDeviceConfiguration")]
        /// Setter for [`memoryBalloonDevices`][Self::memoryBalloonDevices].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setMemoryBalloonDevices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMemoryBalloonDevices(
            &self,
            memory_balloon_devices: &NSArray<VZMemoryBalloonDeviceConfiguration>,
        );

        #[cfg(feature = "VZNetworkDeviceConfiguration")]
        /// List of network adapters. Empty by default.
        ///
        /// See: VZVirtioNetworkDeviceConfiguration
        #[unsafe(method(networkDevices))]
        #[unsafe(method_family = none)]
        pub unsafe fn networkDevices(&self) -> Retained<NSArray<VZNetworkDeviceConfiguration>>;

        #[cfg(feature = "VZNetworkDeviceConfiguration")]
        /// Setter for [`networkDevices`][Self::networkDevices].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setNetworkDevices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setNetworkDevices(
            &self,
            network_devices: &NSArray<VZNetworkDeviceConfiguration>,
        );

        #[cfg(feature = "VZSerialPortConfiguration")]
        /// List of serial ports. Empty by default.
        ///
        /// See: VZVirtioConsoleDeviceSerialPortConfiguration
        #[unsafe(method(serialPorts))]
        #[unsafe(method_family = none)]
        pub unsafe fn serialPorts(&self) -> Retained<NSArray<VZSerialPortConfiguration>>;

        #[cfg(feature = "VZSerialPortConfiguration")]
        /// Setter for [`serialPorts`][Self::serialPorts].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setSerialPorts:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSerialPorts(&self, serial_ports: &NSArray<VZSerialPortConfiguration>);

        #[cfg(feature = "VZSocketDeviceConfiguration")]
        /// List of socket devices. Empty by default.
        ///
        /// See: VZVirtioSocketDeviceConfiguration
        #[unsafe(method(socketDevices))]
        #[unsafe(method_family = none)]
        pub unsafe fn socketDevices(&self) -> Retained<NSArray<VZSocketDeviceConfiguration>>;

        #[cfg(feature = "VZSocketDeviceConfiguration")]
        /// Setter for [`socketDevices`][Self::socketDevices].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setSocketDevices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSocketDevices(
            &self,
            socket_devices: &NSArray<VZSocketDeviceConfiguration>,
        );

        #[cfg(feature = "VZStorageDeviceConfiguration")]
        /// List of disk devices. Empty by default.
        ///
        /// See: VZNVMExpressControllerDeviceConfiguration
        ///
        /// See: VZUSBMassStorageDeviceConfiguration
        ///
        /// See: VZVirtioBlockDeviceConfiguration
        #[unsafe(method(storageDevices))]
        #[unsafe(method_family = none)]
        pub unsafe fn storageDevices(&self) -> Retained<NSArray<VZStorageDeviceConfiguration>>;

        #[cfg(feature = "VZStorageDeviceConfiguration")]
        /// Setter for [`storageDevices`][Self::storageDevices].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setStorageDevices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setStorageDevices(
            &self,
            storage_devices: &NSArray<VZStorageDeviceConfiguration>,
        );

        #[cfg(feature = "VZKeyboardConfiguration")]
        /// List of keyboards. Empty by default.
        ///
        /// See: VZUSBKeyboardConfiguration
        ///
        /// See: VZMacKeyboardConfiguration
        #[unsafe(method(keyboards))]
        #[unsafe(method_family = none)]
        pub unsafe fn keyboards(&self) -> Retained<NSArray<VZKeyboardConfiguration>>;

        #[cfg(feature = "VZKeyboardConfiguration")]
        /// Setter for [`keyboards`][Self::keyboards].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setKeyboards:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setKeyboards(&self, keyboards: &NSArray<VZKeyboardConfiguration>);

        #[cfg(feature = "VZPointingDeviceConfiguration")]
        /// List of pointing devices. Empty by default.
        ///
        /// See: VZUSBScreenCoordinatePointingDeviceConfiguration
        ///
        /// See: VZMacTrackpadConfiguration
        #[unsafe(method(pointingDevices))]
        #[unsafe(method_family = none)]
        pub unsafe fn pointingDevices(&self) -> Retained<NSArray<VZPointingDeviceConfiguration>>;

        #[cfg(feature = "VZPointingDeviceConfiguration")]
        /// Setter for [`pointingDevices`][Self::pointingDevices].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setPointingDevices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPointingDevices(
            &self,
            pointing_devices: &NSArray<VZPointingDeviceConfiguration>,
        );

        #[cfg(feature = "VZGraphicsDeviceConfiguration")]
        /// List of graphics devices. Empty by default.
        ///
        /// See: VZMacGraphicsDeviceConfiguration
        #[unsafe(method(graphicsDevices))]
        #[unsafe(method_family = none)]
        pub unsafe fn graphicsDevices(&self) -> Retained<NSArray<VZGraphicsDeviceConfiguration>>;

        #[cfg(feature = "VZGraphicsDeviceConfiguration")]
        /// Setter for [`graphicsDevices`][Self::graphicsDevices].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setGraphicsDevices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setGraphicsDevices(
            &self,
            graphics_devices: &NSArray<VZGraphicsDeviceConfiguration>,
        );

        #[cfg(feature = "VZUSBControllerConfiguration")]
        /// List of USB Controllers. Empty by default.
        ///
        /// This list represents a set of USB controllers that the virtual machine will start with.
        /// For each entry in this list, there will be a corresponding runtime object created in VZVirtualMachine.usbControllers property.
        ///
        /// See: VZUSBControllerConfiguration
        #[unsafe(method(usbControllers))]
        #[unsafe(method_family = none)]
        pub unsafe fn usbControllers(&self) -> Retained<NSArray<VZUSBControllerConfiguration>>;

        #[cfg(feature = "VZUSBControllerConfiguration")]
        /// Setter for [`usbControllers`][Self::usbControllers].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setUsbControllers:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setUsbControllers(
            &self,
            usb_controllers: &NSArray<VZUSBControllerConfiguration>,
        );
    );
}

/// Methods declared on superclass `NSObject`.
impl VZVirtualMachineConfiguration {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

/// VZVirtualMachineConfigurationValidation.
///
/// Virtual machine configuration runtime validation.
impl VZVirtualMachineConfiguration {
    extern_methods!(
        /// Validate the configuration.
        ///
        /// Parameter `error`: If not nil, assigned with the validation error if the validation failed.
        ///
        /// Returns: YES if the configuration is valid.
        #[unsafe(method(validateWithError:_))]
        #[unsafe(method_family = none)]
        pub unsafe fn validateWithError(&self) -> Result<(), Retained<NSError>>;

        /// Validate the configuration is savable.
        ///
        /// Verify that a virtual machine with this configuration is savable.
        /// Not all configuration options can be safely saved and restored from file.
        /// If this evaluates to NO, the caller should expect future calls to saveMachineStateToURL:completionHandler: to fail.
        ///
        /// Parameter `error`: If not nil, assigned with an error describing the unsupported configuration option.
        ///
        /// Returns: YES if the configuration is savable.
        #[unsafe(method(validateSaveRestoreSupportWithError:_))]
        #[unsafe(method_family = none)]
        pub unsafe fn validateSaveRestoreSupportWithError(&self) -> Result<(), Retained<NSError>>;

        /// Minimum amount of memory required by virtual machines.
        ///
        /// See: VZVirtualMachineConfiguration.memorySize
        #[unsafe(method(minimumAllowedMemorySize))]
        #[unsafe(method_family = none)]
        pub unsafe fn minimumAllowedMemorySize() -> u64;

        /// Maximum amount of memory allowed for a virtual machine.
        ///
        /// See: VZVirtualMachineConfiguration.memorySize
        #[unsafe(method(maximumAllowedMemorySize))]
        #[unsafe(method_family = none)]
        pub unsafe fn maximumAllowedMemorySize() -> u64;

        /// Minimum number of CPUs for a virtual machine.
        ///
        /// See: VZVirtualMachineConfiguration.CPUCount
        #[unsafe(method(minimumAllowedCPUCount))]
        #[unsafe(method_family = none)]
        pub unsafe fn minimumAllowedCPUCount() -> NSUInteger;

        /// Maximum number of CPUs for a virtual machine.
        ///
        /// See: VZVirtualMachineConfiguration.CPUCount
        #[unsafe(method(maximumAllowedCPUCount))]
        #[unsafe(method_family = none)]
        pub unsafe fn maximumAllowedCPUCount() -> NSUInteger;
    );
}