objc2-vision 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::*;
#[cfg(feature = "objc2-core-graphics")]
use objc2_core_graphics::*;
#[cfg(feature = "objc2-core-image")]
use objc2_core_image::*;
#[cfg(feature = "objc2-core-media")]
use objc2_core_media::*;
#[cfg(feature = "objc2-core-video")]
use objc2_core_video::*;
use objc2_foundation::*;
#[cfg(feature = "objc2-image-io")]
use objc2_image_io::*;

use crate::*;

/// The level of optical flow computational accuracy.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/vision/vngenerateopticalflowrequestcomputationaccuracy?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct VNGenerateOpticalFlowRequestComputationAccuracy(pub NSUInteger);
impl VNGenerateOpticalFlowRequestComputationAccuracy {
    #[doc(alias = "VNGenerateOpticalFlowRequestComputationAccuracyLow")]
    pub const Low: Self = Self(0);
    #[doc(alias = "VNGenerateOpticalFlowRequestComputationAccuracyMedium")]
    pub const Medium: Self = Self(1);
    #[doc(alias = "VNGenerateOpticalFlowRequestComputationAccuracyHigh")]
    pub const High: Self = Self(2);
    #[doc(alias = "VNGenerateOpticalFlowRequestComputationAccuracyVeryHigh")]
    pub const VeryHigh: Self = Self(3);
}

unsafe impl Encode for VNGenerateOpticalFlowRequestComputationAccuracy {
    const ENCODING: Encoding = NSUInteger::ENCODING;
}

unsafe impl RefEncode for VNGenerateOpticalFlowRequestComputationAccuracy {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

extern_class!(
    /// VNGenerateOpticalFlowRequest will determine directional change vectors for each pixel in the targeted image to transform it into the image processed
    /// by the request handler, reporting this result with a single VNPixelBufferObservation.
    ///
    ///
    /// Because this request works at the pixel level, both images must have the same dimensions in order for the request to be successfully performed.
    /// Setting a region of interest will isolate where the change determination is performed; however, the resultant observation will still be reported
    /// with a full resolution VNPixelBufferObservation.
    ///
    /// Optical flow requests are very resource intensive, so it is recommended that only one request at a time be created and that the handler
    /// where the request was issued be released immediately after generating optical flows.
    ///
    /// Example usage:
    ///
    /// - (nullable VNPixelBufferObservation*) opticalFlowFromImage:(CVPixelBufferRef)fromImage toImage:(CVPixelBuffer)toImage error:(NSError**)error
    /// {
    /// VNImageRequestHandler* imageRequestHandler = [[VNImageRequestHandler alloc] initWithCVPixelBuffer:fromImage options:
    /// @
    /// {}];
    /// VNGenerateOpticalFlowRequest* request = [[VNGenerateOpticalFlowRequest alloc] initWithTargetedCVPixelBuffer:toImage options:
    /// @
    /// {}];
    /// if (![imageRequestHandler performRequests:
    /// @
    /// [ request ] error:error])
    /// {
    /// return nil;
    /// }
    ///
    /// return [[request results] firstObject];
    /// }
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/vision/vngenerateopticalflowrequest?language=objc)
    #[unsafe(super(VNTargetedImageRequest, VNImageBasedRequest, VNRequest, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(all(feature = "VNRequest", feature = "VNTargetedImageRequest"))]
    pub struct VNGenerateOpticalFlowRequest;
);

#[cfg(all(feature = "VNRequest", feature = "VNTargetedImageRequest"))]
extern_conformance!(
    unsafe impl NSCopying for VNGenerateOpticalFlowRequest {}
);

#[cfg(all(feature = "VNRequest", feature = "VNTargetedImageRequest"))]
unsafe impl CopyingHelper for VNGenerateOpticalFlowRequest {
    type Result = Self;
}

#[cfg(all(feature = "VNRequest", feature = "VNTargetedImageRequest"))]
extern_conformance!(
    unsafe impl NSObjectProtocol for VNGenerateOpticalFlowRequest {}
);

#[cfg(all(feature = "VNRequest", feature = "VNTargetedImageRequest"))]
impl VNGenerateOpticalFlowRequest {
    extern_methods!(
        /// The level of accuracy used to compute the optical flow. Default is VNGenerateOpticalFlowRequestComputationAccuracyMedium.
        ///
        /// The computational time typically trends with the accuracy level.  This parameter allows for selective tuning by the client application.
        #[unsafe(method(computationAccuracy))]
        #[unsafe(method_family = none)]
        pub unsafe fn computationAccuracy(&self)
            -> VNGenerateOpticalFlowRequestComputationAccuracy;

        /// Setter for [`computationAccuracy`][Self::computationAccuracy].
        #[unsafe(method(setComputationAccuracy:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setComputationAccuracy(
            &self,
            computation_accuracy: VNGenerateOpticalFlowRequestComputationAccuracy,
        );

        /// Pixel format type of the output buffer. Valid values are kCVPixelFormatType_TwoComponent32Float and kCVPixelFormatType_TwoComponent16Half.
        /// Default is kCVPixelFormatType_TwoComponent32Float.
        #[unsafe(method(outputPixelFormat))]
        #[unsafe(method_family = none)]
        pub unsafe fn outputPixelFormat(&self) -> OSType;

        /// Setter for [`outputPixelFormat`][Self::outputPixelFormat].
        #[unsafe(method(setOutputPixelFormat:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setOutputPixelFormat(&self, output_pixel_format: OSType);

        /// Setting this to YES will keep the raw pixel buffer coming from the the ML network. The default is NO.
        ///
        /// When set to YES, the outputPixelFormat is ignored. Setting this for revision 1 is a no-op as it is not ML-based.
        #[unsafe(method(keepNetworkOutput))]
        #[unsafe(method_family = none)]
        pub unsafe fn keepNetworkOutput(&self) -> bool;

        /// Setter for [`keepNetworkOutput`][Self::keepNetworkOutput].
        #[unsafe(method(setKeepNetworkOutput:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setKeepNetworkOutput(&self, keep_network_output: bool);

        #[cfg(feature = "VNObservation")]
        /// VNPixelBufferObservation results.
        #[unsafe(method(results))]
        #[unsafe(method_family = none)]
        pub unsafe fn results(&self) -> Option<Retained<NSArray<VNPixelBufferObservation>>>;
    );
}

/// Methods declared on superclass `VNTargetedImageRequest`.
#[cfg(all(feature = "VNRequest", feature = "VNTargetedImageRequest"))]
impl VNGenerateOpticalFlowRequest {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[cfg(feature = "block2")]
        /// # Safety
        ///
        /// `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithCompletionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithCompletionHandler(
            this: Allocated<Self>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(all(feature = "VNRequestHandler", feature = "objc2-core-video"))]
        /// Create a new request that targets an image in a pixel buffer.
        ///
        ///
        /// Parameter `pixelBuffer`: The pixel buffer containing the targeted image.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedCVPixelBuffer:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCVPixelBuffer_options(
            this: Allocated<Self>,
            pixel_buffer: &CVPixelBuffer,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "block2",
            feature = "objc2-core-video"
        ))]
        /// Create a new request that targets an image in a pixel buffer.
        ///
        ///
        /// Parameter `pixelBuffer`: The pixel buffer containing the targeted image.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked when the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedCVPixelBuffer:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCVPixelBuffer_options_completionHandler(
            this: Allocated<Self>,
            pixel_buffer: &CVPixelBuffer,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "objc2-core-video",
            feature = "objc2-image-io"
        ))]
        /// Create a new request that targets an image in a pixel buffer.
        ///
        ///
        /// Parameter `pixelBuffer`: The pixel buffer containing the targeted image.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedCVPixelBuffer:orientation:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCVPixelBuffer_orientation_options(
            this: Allocated<Self>,
            pixel_buffer: &CVPixelBuffer,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "block2",
            feature = "objc2-core-video",
            feature = "objc2-image-io"
        ))]
        /// Create a new request that targets an image in a pixel buffer.
        ///
        ///
        /// Parameter `pixelBuffer`: The pixel buffer containing the targeted image.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked when the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedCVPixelBuffer:orientation:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCVPixelBuffer_orientation_options_completionHandler(
            this: Allocated<Self>,
            pixel_buffer: &CVPixelBuffer,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(all(feature = "VNRequestHandler", feature = "objc2-core-graphics"))]
        /// Create a new request with a targeted CGImage.
        ///
        ///
        /// Parameter `cgImage`: The CGImageRef of the targeted image.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedCGImage:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCGImage_options(
            this: Allocated<Self>,
            cg_image: &CGImage,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "block2",
            feature = "objc2-core-graphics"
        ))]
        /// Create a new request with a targeted CGImage.
        ///
        ///
        /// Parameter `cgImage`: The CGImageRef of the targeted image.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked when the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedCGImage:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCGImage_options_completionHandler(
            this: Allocated<Self>,
            cg_image: &CGImage,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "objc2-core-graphics",
            feature = "objc2-image-io"
        ))]
        /// Create a new request with a targeted CGImage.
        ///
        ///
        /// Parameter `cgImage`: The CGImageRef of the targeted image.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedCGImage:orientation:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCGImage_orientation_options(
            this: Allocated<Self>,
            cg_image: &CGImage,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "block2",
            feature = "objc2-core-graphics",
            feature = "objc2-image-io"
        ))]
        /// Create a new request with a targeted CGImage.
        ///
        ///
        /// Parameter `cgImage`: The CGImageRef of the targeted image.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked when the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedCGImage:orientation:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCGImage_orientation_options_completionHandler(
            this: Allocated<Self>,
            cg_image: &CGImage,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(all(feature = "VNRequestHandler", feature = "objc2-core-image"))]
        /// Create a new request with a targeted CIImage.
        ///
        ///
        /// Parameter `ciImage`: The CIImage of the targeted image.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedCIImage:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCIImage_options(
            this: Allocated<Self>,
            ci_image: &CIImage,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "block2",
            feature = "objc2-core-image"
        ))]
        /// Create a new request with a targeted CIImage.
        ///
        ///
        /// Parameter `ciImage`: The CIImage of the targeted image.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked when the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedCIImage:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCIImage_options_completionHandler(
            this: Allocated<Self>,
            ci_image: &CIImage,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "objc2-core-image",
            feature = "objc2-image-io"
        ))]
        /// Create a new request with a targeted CIImage.
        ///
        ///
        /// Parameter `ciImage`: The CIImage of the targeted image.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedCIImage:orientation:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCIImage_orientation_options(
            this: Allocated<Self>,
            ci_image: &CIImage,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "block2",
            feature = "objc2-core-image",
            feature = "objc2-image-io"
        ))]
        /// Create a new request with a targeted CIImage.
        ///
        ///
        /// Parameter `ciImage`: The CIImage of the targeted image.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked when the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedCIImage:orientation:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCIImage_orientation_options_completionHandler(
            this: Allocated<Self>,
            ci_image: &CIImage,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(feature = "VNRequestHandler")]
        /// Create a new request with a targeted image URL.
        ///
        ///
        /// Parameter `imageURL`: The URL of the targeted image.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedImageURL:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedImageURL_options(
            this: Allocated<Self>,
            image_url: &NSURL,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(feature = "VNRequestHandler", feature = "block2"))]
        /// Create a new request with a targeted image URL.
        ///
        ///
        /// Parameter `imageURL`: The URL of the targeted image.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked when the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedImageURL:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedImageURL_options_completionHandler(
            this: Allocated<Self>,
            image_url: &NSURL,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(all(feature = "VNRequestHandler", feature = "objc2-image-io"))]
        /// Create a new request with a targeted image URL.
        ///
        ///
        /// Parameter `imageURL`: The URL of the targeted image.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedImageURL:orientation:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedImageURL_orientation_options(
            this: Allocated<Self>,
            image_url: &NSURL,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "block2",
            feature = "objc2-image-io"
        ))]
        /// Create a new request with a targeted image URL.
        ///
        ///
        /// Parameter `imageURL`: The URL of the targeted image.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked when the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedImageURL:orientation:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedImageURL_orientation_options_completionHandler(
            this: Allocated<Self>,
            image_url: &NSURL,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(feature = "VNRequestHandler")]
        /// Create a new request with a targeted image data.
        ///
        ///
        /// Parameter `imageData`: The data of the targeted image.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedImageData:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedImageData_options(
            this: Allocated<Self>,
            image_data: &NSData,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(feature = "VNRequestHandler", feature = "block2"))]
        /// Create a new request with a targeted image data.
        ///
        ///
        /// Parameter `imageData`: The data of the targeted image.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked when the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedImageData:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedImageData_options_completionHandler(
            this: Allocated<Self>,
            image_data: &NSData,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(all(feature = "VNRequestHandler", feature = "objc2-image-io"))]
        /// Create a new request with a targeted image data.
        ///
        ///
        /// Parameter `imageData`: The data of the targeted image.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedImageData:orientation:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedImageData_orientation_options(
            this: Allocated<Self>,
            image_data: &NSData,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "block2",
            feature = "objc2-image-io"
        ))]
        /// Create a new request with a targeted image data.
        ///
        ///
        /// Parameter `imageData`: The data of the targeted image.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked when the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedImageData:orientation:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedImageData_orientation_options_completionHandler(
            this: Allocated<Self>,
            image_data: &NSData,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(all(feature = "VNRequestHandler", feature = "objc2-core-media"))]
        /// Create a new request with a targeted CMSampleBuffer.
        ///
        ///
        /// Parameter `sampleBuffer`: The CMSampleBuffer containing the CVImageBuffer to be used by the request.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedCMSampleBuffer:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCMSampleBuffer_options(
            this: Allocated<Self>,
            sample_buffer: &CMSampleBuffer,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "block2",
            feature = "objc2-core-media"
        ))]
        /// Create a new request with a targeted CMSampleBuffer.
        ///
        ///
        /// Parameter `sampleBuffer`: The CMSampleBuffer containing the CVImageBuffer to be used by the request.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked after the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedCMSampleBuffer:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCMSampleBuffer_options_completionHandler(
            this: Allocated<Self>,
            sample_buffer: &CMSampleBuffer,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "objc2-core-media",
            feature = "objc2-image-io"
        ))]
        /// Create a new request with a targeted CMSampleBuffer.
        ///
        ///
        /// Parameter `sampleBuffer`: The CMSampleBuffer containing the CVImageBuffer to be used by the request.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// # Safety
        ///
        /// `options` generic should be of the correct type.
        #[unsafe(method(initWithTargetedCMSampleBuffer:orientation:options:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCMSampleBuffer_orientation_options(
            this: Allocated<Self>,
            sample_buffer: &CMSampleBuffer,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
        ) -> Retained<Self>;

        #[cfg(all(
            feature = "VNRequestHandler",
            feature = "block2",
            feature = "objc2-core-media",
            feature = "objc2-image-io"
        ))]
        /// Create a new request with a targeted CMSampleBuffer.
        ///
        ///
        /// Parameter `sampleBuffer`: The CMSampleBuffer containing the CVImageBuffer to be used by the request.
        ///
        /// Parameter `orientation`: The orientation of the image/buffer based on the EXIF specification. For details see kCGImagePropertyOrientation. The value has to be an integer from 1 to 8. This supersedes every other orientation information.
        ///
        /// Parameter `options`: A dictionary with options specifying auxiliary information for the image.
        ///
        /// Parameter `completionHandler`: The block that is invoked after the request has been performed.
        ///
        /// # Safety
        ///
        /// - `options` generic should be of the correct type.
        /// - `completion_handler` must be a valid pointer or null.
        #[unsafe(method(initWithTargetedCMSampleBuffer:orientation:options:completionHandler:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithTargetedCMSampleBuffer_orientation_options_completionHandler(
            this: Allocated<Self>,
            sample_buffer: &CMSampleBuffer,
            orientation: CGImagePropertyOrientation,
            options: &NSDictionary<VNImageOption, AnyObject>,
            completion_handler: VNRequestCompletionHandler,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
#[cfg(all(feature = "VNRequest", feature = "VNTargetedImageRequest"))]
impl VNGenerateOpticalFlowRequest {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

/// [Apple's documentation](https://developer.apple.com/documentation/vision/vngenerateopticalflowrequestrevision1?language=objc)
pub static VNGenerateOpticalFlowRequestRevision1: NSUInteger = 1;

/// [Apple's documentation](https://developer.apple.com/documentation/vision/vngenerateopticalflowrequestrevision2?language=objc)
pub static VNGenerateOpticalFlowRequestRevision2: NSUInteger = 2;