What's new in Virtualization

public protocol VZCustomVirtioDeviceConfigurationDelegate : NSObjectProtocol {

    /**
     A method the framework calls when it creates a custom Virtio device from a custom Virtio device configuration.
    
      The Virtualization framework creates a ``VZCustomVirtioDevice`` when you call ``VZVirtualMachine/initWithConfiguration:``
      and calls this method on the serial queue of the guest's ``VZVirtualMachine`` instance.
    
     - Parameters:
        - deviceConfiguration: The configuration calling the delegate method.
        - device: The ``VZCustomVirtioDevice`` that the framework created.
     */
    optional func customVirtioConfiguration(_ deviceConfiguration: VZCustomVirtioDeviceConfiguration, didCreateDevice device: VZCustomVirtioDevice)
}

public protocol VZCustomVirtioDeviceDelegate : NSObjectProtocol {

    /**
     The method the framework calls when the device receives a virtqueue (Virtio queue) notification from the guest.
    
     - Parameters:
        - device: The device invoking the delegate method.
        - queue: The queue that received the notification.
     */
    optional func customVirtioDevice(_ device: VZCustomVirtioDevice, didReceiveNotificationFor queue: VZVirtioQueue)

    /**
     The method the framework calls when the device and driver successfully complete Virtio negotiation.
    
     The guest driver sets the status to the value `DRIVER_OK`.
    
     - Parameter device: The device invoking the delegate method.
     */
    optional func customVirtioDeviceDidAcceptDriverOk(_ device: VZCustomVirtioDevice)

    /**
        The method the framework calls when a device will be stopped.
    
        A device is in a stopped state when its corresponding ``VZVirtualMachine`` has stopped. This can happen when the guest performs a shutdown operation itself,  or when you call ``VZVirtualMachine/requestStopWithError:``.
    
        - Parameter device: The device invoking the delegate method.
     */
    optional func customVirtioDeviceWillStop(_ device: VZCustomVirtioDevice)

    /**
        The method the framework calls when a device pauses.
    
        A device is in a paused state when its corresponding ``VZVirtualMachine`` is in a paused state. This happens when you call ``VZVirtualMachine/pauseWithCompletionHandler:``.
    
        - Parameter device: The device invoking the delegate method.
     */
    optional func customVirtioDeviceWillPause(_ device: VZCustomVirtioDevice)

    /**
        The method the framework calls when a device resumes.
    
        A device is in a resumed state when its corresponding ``VZVirtualMachine`` resumes from the paused state.
        This happens when you call ``VZVirtualMachine/resumeWithCompletionHandler:``.
    
        - Parameter device: The device invoking the delegate method.
     */
    optional func customVirtioDeviceWillResume(_ device: VZCustomVirtioDevice)

    /**
     The method the framework calls when a device resets.
    
     You can initiate a reset by calling the ``VZCustomVirtioDevice/requestDeviceReset`` method, and the guest driver can also initiate the reset by itself. The framework calls this method when the reset completes for either scenario.
    
     - Parameter device: The device invoking the delegate method.
     */
    optional func customVirtioDeviceWillReset(_ device: VZCustomVirtioDevice)

    /**
     The method the framework calls when a device needs to save its state.
    
     Return the state data to save in an <doc://com.apple.documentation/documentation/foundation/nsdata> object.
     If there is no state to save, return an empty NSData object ([NSData data]).
    
     If you return `nil` from this method, the save operation fails.
    
     - Parameter device: The device invoking the delegate method.
     */
    optional func customVirtioDeviceSaveState(forRestore device: VZCustomVirtioDevice) -> Data?

    /**
     The method the framework calls when a device restores its state.
    
     This method should return `NO` if restore operation failed.
    
     - Parameters:
        - device: The device invoking the delegate method.
        - saveState: The data that the delegate returned from ``VZCustomVirtioDeviceDelegate/customVirtioDeviceSaveStateForRestore:``.
     */
    optional func customVirtioDeviceShouldRestore(_ device: VZCustomVirtioDevice, saveState: Data) -> Bool
}

extension VZDiskImageStorageDeviceAttachment {

    /// Initialize the attachment from a DiskImage object.
    ///
    /// - Parameters:
    ///   - diskImage: DiskImage object from DiskImageKit framework. Supports both single and stacked disk images.
    ///   - cachingMode: The host-level data caching policy for the disk image. This is independent of cache layers in the disk image stack.
    ///   - synchronizationMode: How the disk image synchronizes with the underlying storage when the guest operating system flushes data.
    ///
    /// This initializer allows using DiskImage objects created with the DiskImageKit framework,
    /// including stacked images with cache and overlay layers.
    public convenience init(diskImage: DiskImage, cachingMode: VZDiskImageCachingMode = .automatic, synchronizationMode: VZDiskImageSynchronizationMode = .full) throws
}

public enum VZEFISignature : Sendable {

    case x509Certificate(SecCertificate)

    case sha256(Data)
}

extension VZEFISignatureList {

    public convenience init(signatures: [VZEFISignature])

    public var signatures: [VZEFISignature] { get }
}

extension VZEFIVariableStore {

    /// A Boolean value that indicates whether Secure Boot is in an enabled state in the variable store.
    public var isSecureBootEnabled: Bool { get throws }

    /// The currently enrolled Key Exchange Key (KEK), allowed signature database (db), and forbidden signature database (dbx) signatures.
    public var enrolledSecureBootSignatures: VZEFISignatureDatabaseConfiguration { get throws }
}

extension VZVirtualMachineView {

    /// The adaptor connecting this view to a virtual machine.
    ///
    /// Setting this property configures the view's virtual machine and display.
    /// When set, the ``VZVirtualMachineView/virtualMachine`` property is automatically set to `nil`.
    /// If the ``VZVirtualMachineView/virtualMachine`` is set, this is reset to `nil`.
    @MainActor @preconcurrency public var adaptor: VZVirtualMachineViewAdaptor?
}

public struct VZVirtualMachineViewAdaptor : @unchecked Sendable {

    /// Initialize an adaptor for a virtual machine.
    ///
    /// If the virtual machine has graphics devices, the first display of the first
    /// graphics device is used. If the virtual machine has no graphics devices,
    /// the adaptor is created successfully but the view will have no display.
    ///
    /// - Parameter virtualMachine: The virtual machine to adapt.
    public init(virtualMachine: VZVirtualMachine)
}

public protocol Delegate : NSObjectProtocol {

    /**
     @abstract Invoked when a USB device's IOService is terminated.
     @discussion
        When invoked, the framework has detached the corresponding
        VZUSBPassthroughDevice from its VZUSBController and removed
        the device from the VZUSBController.usbDevices array.
     @param usbController The VZUSBController invoking the delegate method.
     @param device The VZUSBPassthroughDevice that disconnected.
    */
    optional func usbController(_ usbController: VZUSBController, usbPassthroughDeviceDidDisconnect device: VZUSBPassthroughDevice)
}