objc2_ar_kit/generated/

ARConfiguration.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
#[cfg(feature = "objc2")]
use objc2::__framework_prelude::*;
#[cfg(feature = "objc2-av-foundation")]
use objc2_av_foundation::*;
#[cfg(feature = "objc2-core-location")]
use objc2_core_location::*;
#[cfg(feature = "objc2-foundation")]
use objc2_foundation::*;

use crate::*;

/// Option set indicating semantic understanding types of the image frame.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arframesemantics?language=objc)
// NS_OPTIONS
#[cfg(feature = "objc2")]
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct ARFrameSemantics(pub NSUInteger);
#[cfg(feature = "objc2")]
bitflags::bitflags! {
    impl ARFrameSemantics: NSUInteger {
/// No semantic operation is run.
        #[doc(alias = "ARFrameSemanticNone")]
        const None = 0;
/// Person segmentation.
///
/// A pixel in the image frame that gets classified as person will have an intensity value equal to 'ARSegmentationClassPerson'.
///
/// See: -[ARFrame segmentationBuffer]
///
/// See: ARSegmentationClass
        #[doc(alias = "ARFrameSemanticPersonSegmentation")]
        const PersonSegmentation = 1<<0;
/// Person segmentation with depth.
///
/// A pixel in the image frame that gets classified as person will have an intensity value equal to 'ARSegmentationClassPerson'.
/// Additionally, every pixel in the image frame that gets classified as person will also have a depth value.
///
/// See: -[ARFrame estimatedDepthData]
///
/// See: -[ARFrame segmentationBuffer]
        #[doc(alias = "ARFrameSemanticPersonSegmentationWithDepth")]
        const PersonSegmentationWithDepth = (1<<1)|(1<<0);
/// Body detection.
///
/// Once activated an ARFrame will contain information about a detected body.
///
/// See: -[ARFrame detectedBody]
///
/// See: ARBody2D
        #[doc(alias = "ARFrameSemanticBodyDetection")]
        const BodyDetection = 1<<2;
/// Scene Depth.
///
/// Each capturedImage will have an associated scene depth data.
///
/// See: - [ARFrame sceneDepth]
        #[doc(alias = "ARFrameSemanticSceneDepth")]
        const SceneDepth = 1<<3;
/// Smoothed Scene Depth.
///
/// Each capturedImage will have an associated scene depth data that is temporally smoothed.
///
/// See: - [ARFrame smoothedSceneDepth]
        #[doc(alias = "ARFrameSemanticSmoothedSceneDepth")]
        const SmoothedSceneDepth = 1<<4;
    }
}

#[cfg(feature = "objc2")]
unsafe impl Encode for ARFrameSemantics {
    const ENCODING: Encoding = NSUInteger::ENCODING;
}

#[cfg(feature = "objc2")]
unsafe impl RefEncode for ARFrameSemantics {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

/// Enum constants for indicating the world alignment.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arworldalignment?language=objc)
// NS_ENUM
#[cfg(feature = "objc2")]
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct ARWorldAlignment(pub NSInteger);
#[cfg(feature = "objc2")]
impl ARWorldAlignment {
    /// Aligns the world with gravity that is defined by vector (0, -1, 0).
    #[doc(alias = "ARWorldAlignmentGravity")]
    pub const Gravity: Self = Self(0);
    /// Aligns the world with gravity that is defined by the vector (0, -1, 0)
    /// and heading (w.r.t. True North) that is given by the vector (0, 0, -1).
    #[doc(alias = "ARWorldAlignmentGravityAndHeading")]
    pub const GravityAndHeading: Self = Self(1);
    /// Aligns the world with the camera’s orientation.
    #[doc(alias = "ARWorldAlignmentCamera")]
    pub const Camera: Self = Self(2);
}

#[cfg(feature = "objc2")]
unsafe impl Encode for ARWorldAlignment {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

#[cfg(feature = "objc2")]
unsafe impl RefEncode for ARWorldAlignment {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

/// Enum constants for indicating the mode of environment texturing to run.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arenvironmenttexturing?language=objc)
// NS_ENUM
#[cfg(feature = "objc2")]
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct AREnvironmentTexturing(pub NSInteger);
#[cfg(feature = "objc2")]
impl AREnvironmentTexturing {
    /// No texture information is gathered.
    #[doc(alias = "AREnvironmentTexturingNone")]
    pub const None: Self = Self(0);
    /// Texture information is gathered for the environment.
    /// Environment textures will be generated for AREnvironmentProbes added to the session.
    #[doc(alias = "AREnvironmentTexturingManual")]
    pub const Manual: Self = Self(1);
    /// Texture information is gathered for the environment and probes automatically placed in the scene.
    #[doc(alias = "AREnvironmentTexturingAutomatic")]
    pub const Automatic: Self = Self(2);
}

#[cfg(feature = "objc2")]
unsafe impl Encode for AREnvironmentTexturing {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

#[cfg(feature = "objc2")]
unsafe impl RefEncode for AREnvironmentTexturing {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

/// Types of scene reconstruction.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arscenereconstruction?language=objc)
// NS_OPTIONS
#[cfg(feature = "objc2")]
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct ARSceneReconstruction(pub NSUInteger);
#[cfg(feature = "objc2")]
bitflags::bitflags! {
    impl ARSceneReconstruction: NSUInteger {
/// No scene reconstruction is run.
        #[doc(alias = "ARSceneReconstructionNone")]
        const None = 0;
/// Scene reconstruction generates a mesh of the world
        #[doc(alias = "ARSceneReconstructionMesh")]
        const Mesh = 1<<0;
/// Scene reconstruction generates a mesh of the world with classification for each face.
        #[doc(alias = "ARSceneReconstructionMeshWithClassification")]
        const MeshWithClassification = (1<<1)|(1<<0);
    }
}

#[cfg(feature = "objc2")]
unsafe impl Encode for ARSceneReconstruction {
    const ENCODING: Encoding = NSUInteger::ENCODING;
}

#[cfg(feature = "objc2")]
unsafe impl RefEncode for ARSceneReconstruction {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

#[cfg(feature = "objc2")]
extern_class!(
    /// An object to describe and configure the Augmented Reality techniques to be used in an ARSession.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arconfiguration?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "objc2")]
    pub struct ARConfiguration;
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
extern_conformance!(
    unsafe impl NSCopying for ARConfiguration {}
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
unsafe impl CopyingHelper for ARConfiguration {
    type Result = Self;
}

#[cfg(feature = "objc2")]
extern_conformance!(
    unsafe impl NSObjectProtocol for ARConfiguration {}
);

#[cfg(feature = "objc2")]
impl ARConfiguration {
    extern_methods!(
        /// Determines whether this device supports the ARConfiguration.
        #[unsafe(method(isSupported))]
        #[unsafe(method_family = none)]
        pub unsafe fn isSupported() -> bool;

        #[cfg(all(feature = "ARVideoFormat", feature = "objc2-foundation"))]
        /// A list of supported video formats for this configuration and device.
        ///
        /// The first element in the list is the default format for session output.
        #[unsafe(method(supportedVideoFormats))]
        #[unsafe(method_family = none)]
        pub unsafe fn supportedVideoFormats() -> Retained<NSArray<ARVideoFormat>>;

        #[cfg(feature = "ARVideoFormat")]
        /// Video format of the session output.
        #[unsafe(method(videoFormat))]
        #[unsafe(method_family = none)]
        pub unsafe fn videoFormat(&self) -> Retained<ARVideoFormat>;

        #[cfg(feature = "ARVideoFormat")]
        /// Setter for [`videoFormat`][Self::videoFormat].
        #[unsafe(method(setVideoFormat:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setVideoFormat(&self, video_format: &ARVideoFormat);

        /// Determines how the coordinate system should be aligned with the world.
        ///
        /// The default is ARWorldAlignmentGravity.
        #[unsafe(method(worldAlignment))]
        #[unsafe(method_family = none)]
        pub unsafe fn worldAlignment(&self) -> ARWorldAlignment;

        /// Setter for [`worldAlignment`][Self::worldAlignment].
        #[unsafe(method(setWorldAlignment:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setWorldAlignment(&self, world_alignment: ARWorldAlignment);

        /// Enable or disable light estimation.
        ///
        /// Enabled by default.
        #[unsafe(method(isLightEstimationEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn isLightEstimationEnabled(&self) -> bool;

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

        /// Determines whether to capture and provide audio data.
        ///
        /// Disabled by default.
        #[unsafe(method(providesAudioData))]
        #[unsafe(method_family = none)]
        pub unsafe fn providesAudioData(&self) -> bool;

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

        /// The type of semantic understanding to provide with each frame.
        ///
        ///
        /// Use the `supportsFrameSemantics` class method to check if the configuration type you intend to run supports the set of frame semantics.
        /// For example, when running a session with a configuration of type ARWorldTrackingConfiguration one would need to use `+[ ARWorldTrackingConfiguration
        /// supportsFrameSemantics:]` to perform said check. An exception is thrown if the option is not supported. Defaults to ARFrameSemanticNone.
        ///
        /// See: ARFrameSemantics
        ///
        /// See: +[ARConfiguration supportsFrameSemantics:]
        #[unsafe(method(frameSemantics))]
        #[unsafe(method_family = none)]
        pub unsafe fn frameSemantics(&self) -> ARFrameSemantics;

        /// Setter for [`frameSemantics`][Self::frameSemantics].
        #[unsafe(method(setFrameSemantics:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setFrameSemantics(&self, frame_semantics: ARFrameSemantics);

        /// Determines whether the type of frame semantics is supported by the device and ARConfiguration class.
        ///
        ///
        /// Semantic frame understanding is not supported on all devices. Use the `supportsFrameSemantics` class method to check if the configuration
        /// type you intend to run supports the set of frame semantics. For example, when running a session with a configuration of type
        /// ARWorldTrackingConfiguration one would need to use
        /// `+[ ARWorldTrackingConfiguration supportsFrameSemantics:]` to perform said check.
        ///
        /// See: ARFrameSemantics
        #[unsafe(method(supportsFrameSemantics:))]
        #[unsafe(method_family = none)]
        pub unsafe fn supportsFrameSemantics(frame_semantics: ARFrameSemantics) -> bool;

        #[cfg(feature = "objc2-av-foundation")]
        /// Returns a pointer to the capture device of the camera that's used for rendering, so developers can adjust capture settings.
        ///
        /// May return nil if it is not recommended to modify capture settings, for example if the primary camera is used for tracking.
        #[unsafe(method(configurableCaptureDeviceForPrimaryCamera))]
        #[unsafe(method_family = none)]
        pub unsafe fn configurableCaptureDeviceForPrimaryCamera(
        ) -> Option<Retained<AVCaptureDevice>>;

        #[cfg(feature = "ARVideoFormat")]
        /// Returns a video format using a 4K resolution from the list of supported video formats.
        ///
        /// May return nil if 4K is not supported for this configuration or device.
        #[unsafe(method(recommendedVideoFormatFor4KResolution))]
        #[unsafe(method_family = none)]
        pub unsafe fn recommendedVideoFormatFor4KResolution() -> Option<Retained<ARVideoFormat>>;

        #[cfg(feature = "ARVideoFormat")]
        /// Returns a recommended video format that supports capturing high resolution frames with a significantly higher resolution than the streaming camera
        /// resolution.
        ///
        /// Using this format may consume more power. Other video formats may support capturing high resolution frames as well, albeit at a lower
        /// quality or resolution.
        ///
        /// See: [ARSession captureHighResolutionFrameWithCompletion:]
        #[unsafe(method(recommendedVideoFormatForHighResolutionFrameCapturing))]
        #[unsafe(method_family = none)]
        pub unsafe fn recommendedVideoFormatForHighResolutionFrameCapturing(
        ) -> Option<Retained<ARVideoFormat>>;

        /// Whether HDR capturing is allowed if the current video format supports it. Defaults to
        /// `NO.`
        #[unsafe(method(videoHDRAllowed))]
        #[unsafe(method_family = none)]
        pub unsafe fn videoHDRAllowed(&self) -> bool;

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

        /// Unavailable
        #[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>;
    );
}

#[cfg(feature = "objc2")]
extern_class!(
    /// A configuration for running world tracking.
    ///
    ///
    /// World tracking provides 6 degrees of freedom tracking of the device.
    /// By finding feature points in the scene, world tracking enables performing hit-tests against the frame.
    /// Tracking can no longer be resumed once the session is paused.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arworldtrackingconfiguration?language=objc)
    #[unsafe(super(ARConfiguration, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "objc2")]
    pub struct ARWorldTrackingConfiguration;
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
extern_conformance!(
    unsafe impl NSCopying for ARWorldTrackingConfiguration {}
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
unsafe impl CopyingHelper for ARWorldTrackingConfiguration {
    type Result = Self;
}

#[cfg(feature = "objc2")]
extern_conformance!(
    unsafe impl NSObjectProtocol for ARWorldTrackingConfiguration {}
);

#[cfg(feature = "objc2")]
impl ARWorldTrackingConfiguration {
    extern_methods!(
        /// Enable or disable continuous auto focus.
        ///
        /// Enabled by default.
        #[unsafe(method(isAutoFocusEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn isAutoFocusEnabled(&self) -> bool;

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

        /// The mode of environment texturing to run.
        ///
        /// If set, texture information will be accumulated and updated. Adding an AREnvironmentProbeAnchor to the session
        /// will get the current environment texture available from that probe's perspective which can be used for lighting
        /// virtual objects in the scene. Defaults to AREnvironmentTexturingNone.
        #[unsafe(method(environmentTexturing))]
        #[unsafe(method_family = none)]
        pub unsafe fn environmentTexturing(&self) -> AREnvironmentTexturing;

        /// Setter for [`environmentTexturing`][Self::environmentTexturing].
        #[unsafe(method(setEnvironmentTexturing:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setEnvironmentTexturing(&self, environment_texturing: AREnvironmentTexturing);

        /// Determines whether environment textures will be provided with high dynamic range. Enabled by default.
        #[unsafe(method(wantsHDREnvironmentTextures))]
        #[unsafe(method_family = none)]
        pub unsafe fn wantsHDREnvironmentTextures(&self) -> bool;

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

        #[cfg(feature = "ARPlaneDetectionTypes")]
        /// Type of planes to detect in the scene.
        ///
        /// If set, new planes will continue to be detected and updated over time. Detected planes will be added to the session as
        /// ARPlaneAnchor objects. In the event that two planes are merged, the newer plane will be removed. Defaults to ARPlaneDetectionNone.
        #[unsafe(method(planeDetection))]
        #[unsafe(method_family = none)]
        pub unsafe fn planeDetection(&self) -> ARPlaneDetection;

        #[cfg(feature = "ARPlaneDetectionTypes")]
        /// Setter for [`planeDetection`][Self::planeDetection].
        #[unsafe(method(setPlaneDetection:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPlaneDetection(&self, plane_detection: ARPlaneDetection);

        #[cfg(feature = "ARWorldMap")]
        /// The initial map of the physical space that world tracking will localize to and track.
        ///
        /// If set, the session will attempt to localize to the provided map with
        /// a limited tracking state until localization is successful or run is called again
        /// with a different (or no) initial map specified. Once localized, the map will be extended
        /// and can again be saved using the `getCurrentWorldMap` method on the session.
        #[unsafe(method(initialWorldMap))]
        #[unsafe(method_family = none)]
        pub unsafe fn initialWorldMap(&self) -> Option<Retained<ARWorldMap>>;

        #[cfg(feature = "ARWorldMap")]
        /// Setter for [`initialWorldMap`][Self::initialWorldMap].
        #[unsafe(method(setInitialWorldMap:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setInitialWorldMap(&self, initial_world_map: Option<&ARWorldMap>);

        #[cfg(all(feature = "ARReferenceImage", feature = "objc2-foundation"))]
        /// Images to detect in the scene.
        ///
        /// If set the session will attempt to detect the specified images. When an image is detected an ARImageAnchor will be added to the session.
        #[unsafe(method(detectionImages))]
        #[unsafe(method_family = none)]
        pub unsafe fn detectionImages(&self) -> Retained<NSSet<ARReferenceImage>>;

        #[cfg(all(feature = "ARReferenceImage", feature = "objc2-foundation"))]
        /// Setter for [`detectionImages`][Self::detectionImages].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setDetectionImages:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDetectionImages(&self, detection_images: Option<&NSSet<ARReferenceImage>>);

        /// Enables the estimation of a scale factor which may be used to correct the physical size of an image.
        ///
        /// If set to true ARKit will attempt to use the computed camera positions in order to compute the scale by which the given physical size
        /// differs from the estimated one. The information about the estimated scale can be found as the property estimatedScaleFactor on the ARImageAnchor.
        ///
        /// Note: When set to true the transform of a returned ARImageAnchor will use the estimated scale factor to correct the translation. Default value is NO.
        #[unsafe(method(automaticImageScaleEstimationEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn automaticImageScaleEstimationEnabled(&self) -> bool;

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

        /// Maximum number of images to track simultaneously.
        ///
        /// Setting the maximum number of tracked images will limit the number of images that can be tracked in a given frame.
        /// If more than the maximum is visible, only the images already being tracked will continue to track until tracking is lost or another image is removed.
        /// Images will continue to be detected regardless of images tracked. Default value is zero.
        #[unsafe(method(maximumNumberOfTrackedImages))]
        #[unsafe(method_family = none)]
        pub unsafe fn maximumNumberOfTrackedImages(&self) -> NSInteger;

        /// Setter for [`maximumNumberOfTrackedImages`][Self::maximumNumberOfTrackedImages].
        #[unsafe(method(setMaximumNumberOfTrackedImages:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMaximumNumberOfTrackedImages(
            &self,
            maximum_number_of_tracked_images: NSInteger,
        );

        #[cfg(all(feature = "ARReferenceObject", feature = "objc2-foundation"))]
        /// Objects to detect in the scene.
        ///
        /// If set the session will attempt to detect the specified objects. When an object is detected an ARObjectAnchor will be added to the
        /// session.
        #[unsafe(method(detectionObjects))]
        #[unsafe(method_family = none)]
        pub unsafe fn detectionObjects(&self) -> Retained<NSSet<ARReferenceObject>>;

        #[cfg(all(feature = "ARReferenceObject", feature = "objc2-foundation"))]
        /// Setter for [`detectionObjects`][Self::detectionObjects].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setDetectionObjects:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDetectionObjects(&self, detection_objects: &NSSet<ARReferenceObject>);

        /// Enable/disable a collaborative session. Disabled by default.
        ///
        ///
        /// When enabled, ARSession will output collaboration data for other participants using its delegate didOutputCollaborationData.
        /// It is the responsibility of the caller to send the data to each participant. When data is received by a participant, it
        /// should be passed to the ARSession by calling updateWithCollaborationData.
        #[unsafe(method(isCollaborationEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn isCollaborationEnabled(&self) -> bool;

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

        /// Indicates whether user face tracking using the front facing camera can be enabled on this device.
        #[unsafe(method(supportsUserFaceTracking))]
        #[unsafe(method_family = none)]
        pub unsafe fn supportsUserFaceTracking() -> bool;

        /// Enable or disable running Face Tracking using the front facing camera. Disabled by default.
        /// When enabled, ARSession detects faces (if visible in the front-facing camera image) and adds to its list of anchors,
        /// an ARFaceAnchor object representing each face.
        ///
        ///
        /// The transform of the ARFaceAnchor objects will be in the world coordinate space.
        ///
        /// See: ARFaceAnchor
        #[unsafe(method(userFaceTrackingEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn userFaceTrackingEnabled(&self) -> bool;

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

        /// Enable or disable app clip code tracking. Disabled by default. When enabled, detected app clip codes will be surfaced as an ARAppClipCodeAnchor.
        #[unsafe(method(appClipCodeTrackingEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn appClipCodeTrackingEnabled(&self) -> bool;

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

        /// Indicates whether app clip code tracking can be enabled on this device.
        #[unsafe(method(supportsAppClipCodeTracking))]
        #[unsafe(method_family = none)]
        pub unsafe fn supportsAppClipCodeTracking() -> bool;

        /// Indicates whether the scene reconstruction type is supported for the configuration on this device.
        #[unsafe(method(supportsSceneReconstruction:))]
        #[unsafe(method_family = none)]
        pub unsafe fn supportsSceneReconstruction(
            scene_reconstruction: ARSceneReconstruction,
        ) -> bool;

        /// Type of scene reconstruction to run. Defaults to ARSceneReconstructionNone.
        ///
        /// See: ARMeshAnchor
        ///
        /// If set to a value other than ARSceneReconstructionNone, output of scene reconstruction will be added to the session as
        /// ARMeshAnchor objects.
        #[unsafe(method(sceneReconstruction))]
        #[unsafe(method_family = none)]
        pub unsafe fn sceneReconstruction(&self) -> ARSceneReconstruction;

        /// Setter for [`sceneReconstruction`][Self::sceneReconstruction].
        #[unsafe(method(setSceneReconstruction:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSceneReconstruction(&self, scene_reconstruction: ARSceneReconstruction);

        #[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>;
    );
}

#[cfg(feature = "objc2")]
extern_class!(
    /// A configuration for running orientation tracking.
    ///
    ///
    /// Orientation tracking provides 3 degrees of freedom tracking of the device.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arorientationtrackingconfiguration?language=objc)
    #[unsafe(super(ARConfiguration, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "objc2")]
    pub struct AROrientationTrackingConfiguration;
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
extern_conformance!(
    unsafe impl NSCopying for AROrientationTrackingConfiguration {}
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
unsafe impl CopyingHelper for AROrientationTrackingConfiguration {
    type Result = Self;
}

#[cfg(feature = "objc2")]
extern_conformance!(
    unsafe impl NSObjectProtocol for AROrientationTrackingConfiguration {}
);

#[cfg(feature = "objc2")]
impl AROrientationTrackingConfiguration {
    extern_methods!(
        /// Enable or disable continuous auto focus.
        ///
        /// Enabled by default.
        #[unsafe(method(isAutoFocusEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn isAutoFocusEnabled(&self) -> bool;

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

        #[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>;
    );
}

#[cfg(feature = "objc2")]
extern_class!(
    /// A configuration for running face tracking.
    ///
    ///
    /// Face tracking uses the front facing camera to track the face in 3D providing details on the topology and expression of the face.
    /// A detected face will be added to the session as an ARFaceAnchor object which contains information about head pose, mesh, eye pose, and blend shape
    /// coefficients. If light estimation is enabled the detected face will be treated as a light probe and used to estimate the direction of incoming light.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arfacetrackingconfiguration?language=objc)
    #[unsafe(super(ARConfiguration, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "objc2")]
    pub struct ARFaceTrackingConfiguration;
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
extern_conformance!(
    unsafe impl NSCopying for ARFaceTrackingConfiguration {}
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
unsafe impl CopyingHelper for ARFaceTrackingConfiguration {
    type Result = Self;
}

#[cfg(feature = "objc2")]
extern_conformance!(
    unsafe impl NSObjectProtocol for ARFaceTrackingConfiguration {}
);

#[cfg(feature = "objc2")]
impl ARFaceTrackingConfiguration {
    extern_methods!(
        /// Maximum number of faces which can be tracked simultaneously.
        #[unsafe(method(supportedNumberOfTrackedFaces))]
        #[unsafe(method_family = none)]
        pub unsafe fn supportedNumberOfTrackedFaces() -> NSInteger;

        /// Maximum number of faces to track simultaneously.
        ///
        /// Setting the maximum number of tracked faces will limit the number of faces that can be tracked in a given frame.
        /// If more than the maximum is visible, only the faces already being tracked will continue to track until tracking is lost or another face is removed.
        /// Default value is one.
        #[unsafe(method(maximumNumberOfTrackedFaces))]
        #[unsafe(method_family = none)]
        pub unsafe fn maximumNumberOfTrackedFaces(&self) -> NSInteger;

        /// Setter for [`maximumNumberOfTrackedFaces`][Self::maximumNumberOfTrackedFaces].
        #[unsafe(method(setMaximumNumberOfTrackedFaces:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMaximumNumberOfTrackedFaces(
            &self,
            maximum_number_of_tracked_faces: NSInteger,
        );

        /// Indicates whether world tracking can be enabled on this device.
        #[unsafe(method(supportsWorldTracking))]
        #[unsafe(method_family = none)]
        pub unsafe fn supportsWorldTracking() -> bool;

        /// Enable or disable World Tracking. Disabled by default.
        ///
        ///
        /// When enabled, ARSession uses the back facing camera to track the device's orientation and position in the world. The camera transform and
        /// the ARFaceAnchor transform will be in the world coordinate space.
        #[unsafe(method(isWorldTrackingEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn isWorldTrackingEnabled(&self) -> bool;

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

        #[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>;
    );
}

#[cfg(feature = "objc2")]
extern_class!(
    /// A configuration for running image tracking.
    ///
    ///
    /// Image tracking provides 6 degrees of freedom tracking of known images. Four images may be tracked simultaneously.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arimagetrackingconfiguration?language=objc)
    #[unsafe(super(ARConfiguration, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "objc2")]
    pub struct ARImageTrackingConfiguration;
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
extern_conformance!(
    unsafe impl NSCopying for ARImageTrackingConfiguration {}
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
unsafe impl CopyingHelper for ARImageTrackingConfiguration {
    type Result = Self;
}

#[cfg(feature = "objc2")]
extern_conformance!(
    unsafe impl NSObjectProtocol for ARImageTrackingConfiguration {}
);

#[cfg(feature = "objc2")]
impl ARImageTrackingConfiguration {
    extern_methods!(
        /// Enable or disable continuous auto focus.
        ///
        /// Enabled by default.
        #[unsafe(method(isAutoFocusEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn isAutoFocusEnabled(&self) -> bool;

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

        #[cfg(all(feature = "ARReferenceImage", feature = "objc2-foundation"))]
        /// Images to track in the scene.
        #[unsafe(method(trackingImages))]
        #[unsafe(method_family = none)]
        pub unsafe fn trackingImages(&self) -> Retained<NSSet<ARReferenceImage>>;

        #[cfg(all(feature = "ARReferenceImage", feature = "objc2-foundation"))]
        /// Setter for [`trackingImages`][Self::trackingImages].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setTrackingImages:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setTrackingImages(&self, tracking_images: &NSSet<ARReferenceImage>);

        /// Maximum number of images to track simultaneously.
        ///
        /// Setting the maximum number of tracked images will limit the number of images that can be tracked in a given frame.
        /// If more than the maximum is visible, only the images already being tracked will continue to track until tracking is lost or another image is removed.
        /// Default value is one.
        #[unsafe(method(maximumNumberOfTrackedImages))]
        #[unsafe(method_family = none)]
        pub unsafe fn maximumNumberOfTrackedImages(&self) -> NSInteger;

        /// Setter for [`maximumNumberOfTrackedImages`][Self::maximumNumberOfTrackedImages].
        #[unsafe(method(setMaximumNumberOfTrackedImages:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMaximumNumberOfTrackedImages(
            &self,
            maximum_number_of_tracked_images: NSInteger,
        );

        #[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>;
    );
}

#[cfg(feature = "objc2")]
extern_class!(
    /// A configuration for scanning objects.
    ///
    ///
    /// The object scanning configuration runs world tracking, capturing additional detail in order to create reference objects.
    /// Running object scanning will consume additional power in order to provide more detailed features.
    /// The createReferenceObject method can be called on the session to capture a scan of an object in the world.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arobjectscanningconfiguration?language=objc)
    #[unsafe(super(ARConfiguration, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "objc2")]
    pub struct ARObjectScanningConfiguration;
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
extern_conformance!(
    unsafe impl NSCopying for ARObjectScanningConfiguration {}
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
unsafe impl CopyingHelper for ARObjectScanningConfiguration {
    type Result = Self;
}

#[cfg(feature = "objc2")]
extern_conformance!(
    unsafe impl NSObjectProtocol for ARObjectScanningConfiguration {}
);

#[cfg(feature = "objc2")]
impl ARObjectScanningConfiguration {
    extern_methods!(
        /// Enable or disable continuous auto focus.
        ///
        /// Enabled by default.
        #[unsafe(method(isAutoFocusEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn isAutoFocusEnabled(&self) -> bool;

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

        #[cfg(feature = "ARPlaneDetectionTypes")]
        /// Type of planes to detect in the scene.
        ///
        /// If set, new planes will continue to be detected and updated over time. Detected planes will be added to the session as
        /// ARPlaneAnchor objects. In the event that two planes are merged, the newer plane will be removed. Defaults to ARPlaneDetectionNone.
        #[unsafe(method(planeDetection))]
        #[unsafe(method_family = none)]
        pub unsafe fn planeDetection(&self) -> ARPlaneDetection;

        #[cfg(feature = "ARPlaneDetectionTypes")]
        /// Setter for [`planeDetection`][Self::planeDetection].
        #[unsafe(method(setPlaneDetection:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPlaneDetection(&self, plane_detection: ARPlaneDetection);

        #[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>;
    );
}

#[cfg(feature = "objc2")]
extern_class!(
    /// A configuration for running body tracking.
    ///
    ///
    /// Body tracking provides 6 degrees of freedom tracking of a detected body in the scene. By default, ARFrameSemanticBodyDetection will be
    /// enabled.
    ///
    /// See: ARBodyAnchor
    ///
    /// See: -[ARFrame detectedBody]
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arbodytrackingconfiguration?language=objc)
    #[unsafe(super(ARConfiguration, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "objc2")]
    pub struct ARBodyTrackingConfiguration;
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
extern_conformance!(
    unsafe impl NSCopying for ARBodyTrackingConfiguration {}
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
unsafe impl CopyingHelper for ARBodyTrackingConfiguration {
    type Result = Self;
}

#[cfg(feature = "objc2")]
extern_conformance!(
    unsafe impl NSObjectProtocol for ARBodyTrackingConfiguration {}
);

#[cfg(feature = "objc2")]
impl ARBodyTrackingConfiguration {
    extern_methods!(
        /// Enable or disable continuous auto focus.
        ///
        /// Enabled by default.
        #[unsafe(method(isAutoFocusEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn isAutoFocusEnabled(&self) -> bool;

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

        #[cfg(feature = "ARWorldMap")]
        /// The initial map of the physical space that world tracking will localize to and track.
        ///
        /// If set, the session will attempt to localize to the provided map with
        /// a limited tracking state until localization is successful or run is called again
        /// with a different (or no) initial map specified. Once localized, the map will be extended
        /// and can again be saved using the `getCurrentWorldMap` method on the session.
        #[unsafe(method(initialWorldMap))]
        #[unsafe(method_family = none)]
        pub unsafe fn initialWorldMap(&self) -> Option<Retained<ARWorldMap>>;

        #[cfg(feature = "ARWorldMap")]
        /// Setter for [`initialWorldMap`][Self::initialWorldMap].
        #[unsafe(method(setInitialWorldMap:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setInitialWorldMap(&self, initial_world_map: Option<&ARWorldMap>);

        /// The mode of environment texturing to run.
        ///
        /// If set, texture information will be accumulated and updated. Adding an AREnvironmentProbeAnchor to the session
        /// will get the current environment texture available from that probe's perspective which can be used for lighting
        /// virtual objects in the scene. Defaults to AREnvironmentTexturingNone.
        #[unsafe(method(environmentTexturing))]
        #[unsafe(method_family = none)]
        pub unsafe fn environmentTexturing(&self) -> AREnvironmentTexturing;

        /// Setter for [`environmentTexturing`][Self::environmentTexturing].
        #[unsafe(method(setEnvironmentTexturing:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setEnvironmentTexturing(&self, environment_texturing: AREnvironmentTexturing);

        /// Determines whether environment textures will be provided with high dynamic range. Enabled by default.
        #[unsafe(method(wantsHDREnvironmentTextures))]
        #[unsafe(method_family = none)]
        pub unsafe fn wantsHDREnvironmentTextures(&self) -> bool;

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

        #[cfg(feature = "ARPlaneDetectionTypes")]
        /// Type of planes to detect in the scene.
        ///
        /// If set, new planes will continue to be detected and updated over time. Detected planes will be added to the session as
        /// ARPlaneAnchor objects. In the event that two planes are merged, the newer plane will be removed. Defaults to ARPlaneDetectionNone.
        #[unsafe(method(planeDetection))]
        #[unsafe(method_family = none)]
        pub unsafe fn planeDetection(&self) -> ARPlaneDetection;

        #[cfg(feature = "ARPlaneDetectionTypes")]
        /// Setter for [`planeDetection`][Self::planeDetection].
        #[unsafe(method(setPlaneDetection:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPlaneDetection(&self, plane_detection: ARPlaneDetection);

        #[cfg(all(feature = "ARReferenceImage", feature = "objc2-foundation"))]
        /// Images to detect in the scene.
        ///
        /// If set the session will attempt to detect the specified images. When an image is detected an ARImageAnchor will be added to the session.
        #[unsafe(method(detectionImages))]
        #[unsafe(method_family = none)]
        pub unsafe fn detectionImages(&self) -> Retained<NSSet<ARReferenceImage>>;

        #[cfg(all(feature = "ARReferenceImage", feature = "objc2-foundation"))]
        /// Setter for [`detectionImages`][Self::detectionImages].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setDetectionImages:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDetectionImages(&self, detection_images: &NSSet<ARReferenceImage>);

        /// Enables the estimation of a scale factor which may be used to correct the physical size of an image.
        ///
        /// If set to true ARKit will attempt to use the computed camera positions in order to compute the scale by which the given physical size
        /// differs from the estimated one. The information about the estimated scale can be found as the property estimatedScaleFactor on the ARImageAnchor.
        ///
        /// Note: When set to true the transform of a returned ARImageAnchor will use the estimated scale factor to correct the translation. Default value is NO.
        #[unsafe(method(automaticImageScaleEstimationEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn automaticImageScaleEstimationEnabled(&self) -> bool;

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

        /// Enables the estimation of a scale factor which may be used to correct the physical size of a skeleton in 3D.
        ///
        /// If set to true ARKit will attempt to use the computed camera positions in order to compute the scale by which the given physical size
        /// differs from the default one. The information about the estimated scale can be found as the property estimatedScaleFactor on the ARBodyAnchor.
        ///
        /// Note: When set to true the transform of a returned ARBodyAnchor will use the estimated scale factor to correct the translation. Default value is NO.
        #[unsafe(method(automaticSkeletonScaleEstimationEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn automaticSkeletonScaleEstimationEnabled(&self) -> bool;

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

        /// Maximum number of images to track simultaneously.
        ///
        /// Setting the maximum number of tracked images will limit the number of images that can be tracked in a given frame.
        /// If more than the maximum is visible, only the images already being tracked will continue to track until tracking is lost or another image is removed.
        /// Images will continue to be detected regardless of images tracked. Default value is zero.
        #[unsafe(method(maximumNumberOfTrackedImages))]
        #[unsafe(method_family = none)]
        pub unsafe fn maximumNumberOfTrackedImages(&self) -> NSInteger;

        /// Setter for [`maximumNumberOfTrackedImages`][Self::maximumNumberOfTrackedImages].
        #[unsafe(method(setMaximumNumberOfTrackedImages:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMaximumNumberOfTrackedImages(
            &self,
            maximum_number_of_tracked_images: NSInteger,
        );

        /// Enable or disable app clip code tracking. Disabled by default. When enabled, detected app clip codes will be surfaced as an ARAppClipCodeAnchor.
        #[unsafe(method(appClipCodeTrackingEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn appClipCodeTrackingEnabled(&self) -> bool;

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

        /// Indicates whether app clip code tracking can be enabled on this device.
        #[unsafe(method(supportsAppClipCodeTracking))]
        #[unsafe(method_family = none)]
        pub unsafe fn supportsAppClipCodeTracking() -> bool;

        #[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>;
    );
}

#[cfg(feature = "objc2")]
extern_class!(
    /// A configuration for running positional tracking.
    ///
    ///
    /// Positional tracking provides 6 degrees of freedom tracking of the device by running the camera at lowest possible resolution and frame
    /// rate.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/arpositionaltrackingconfiguration?language=objc)
    #[unsafe(super(ARConfiguration, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "objc2")]
    pub struct ARPositionalTrackingConfiguration;
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
extern_conformance!(
    unsafe impl NSCopying for ARPositionalTrackingConfiguration {}
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
unsafe impl CopyingHelper for ARPositionalTrackingConfiguration {
    type Result = Self;
}

#[cfg(feature = "objc2")]
extern_conformance!(
    unsafe impl NSObjectProtocol for ARPositionalTrackingConfiguration {}
);

#[cfg(feature = "objc2")]
impl ARPositionalTrackingConfiguration {
    extern_methods!(
        #[cfg(feature = "ARPlaneDetectionTypes")]
        /// Type of planes to detect in the scene.
        ///
        /// If set, new planes will continue to be detected and updated over time. Detected planes will be added to the session as
        /// ARPlaneAnchor objects. In the event that two planes are merged, the newer plane will be removed. Defaults to ARPlaneDetectionNone.
        #[unsafe(method(planeDetection))]
        #[unsafe(method_family = none)]
        pub unsafe fn planeDetection(&self) -> ARPlaneDetection;

        #[cfg(feature = "ARPlaneDetectionTypes")]
        /// Setter for [`planeDetection`][Self::planeDetection].
        #[unsafe(method(setPlaneDetection:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPlaneDetection(&self, plane_detection: ARPlaneDetection);

        #[cfg(feature = "ARWorldMap")]
        /// The initial map of the physical space that world tracking will localize to and track.
        ///
        /// If set, the session will attempt to localize to the provided map with
        /// a limited tracking state until localization is successful or run is called again
        /// with a different (or no) initial map specified. Once localized, the map will be extended
        /// and can again be saved using the `getCurrentWorldMap` method on the session.
        #[unsafe(method(initialWorldMap))]
        #[unsafe(method_family = none)]
        pub unsafe fn initialWorldMap(&self) -> Option<Retained<ARWorldMap>>;

        #[cfg(feature = "ARWorldMap")]
        /// Setter for [`initialWorldMap`][Self::initialWorldMap].
        #[unsafe(method(setInitialWorldMap:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setInitialWorldMap(&self, initial_world_map: Option<&ARWorldMap>);

        #[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>;
    );
}

#[cfg(feature = "objc2")]
extern_class!(
    /// A configuration for running geographical world tracking.
    ///
    ///
    /// It allows placing geo-referenced anchors (ARGeoAnchor) in the scene by running world tracking with location and compass.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/arkit/argeotrackingconfiguration?language=objc)
    #[unsafe(super(ARConfiguration, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    #[cfg(feature = "objc2")]
    pub struct ARGeoTrackingConfiguration;
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
extern_conformance!(
    unsafe impl NSCopying for ARGeoTrackingConfiguration {}
);

#[cfg(all(feature = "objc2", feature = "objc2-foundation"))]
unsafe impl CopyingHelper for ARGeoTrackingConfiguration {
    type Result = Self;
}

#[cfg(feature = "objc2")]
extern_conformance!(
    unsafe impl NSObjectProtocol for ARGeoTrackingConfiguration {}
);

#[cfg(feature = "objc2")]
impl ARGeoTrackingConfiguration {
    extern_methods!(
        /// Unavailable
        #[unsafe(method(worldAlignment))]
        #[unsafe(method_family = none)]
        pub unsafe fn worldAlignment(&self) -> ARWorldAlignment;

        /// Setter for [`worldAlignment`][Self::worldAlignment].
        #[unsafe(method(setWorldAlignment:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setWorldAlignment(&self, world_alignment: ARWorldAlignment);

        /// The mode of environment texturing to run.
        ///
        /// If set, texture information will be accumulated and updated. Adding an AREnvironmentProbeAnchor to the session
        /// will get the current environment texture available from that probe's perspective which can be used for lighting
        /// virtual objects in the scene. Defaults to AREnvironmentTexturingNone.
        #[unsafe(method(environmentTexturing))]
        #[unsafe(method_family = none)]
        pub unsafe fn environmentTexturing(&self) -> AREnvironmentTexturing;

        /// Setter for [`environmentTexturing`][Self::environmentTexturing].
        #[unsafe(method(setEnvironmentTexturing:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setEnvironmentTexturing(&self, environment_texturing: AREnvironmentTexturing);

        /// Determines whether environment textures will be provided with high dynamic range. Enabled by default.
        #[unsafe(method(wantsHDREnvironmentTextures))]
        #[unsafe(method_family = none)]
        pub unsafe fn wantsHDREnvironmentTextures(&self) -> bool;

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

        #[cfg(feature = "ARPlaneDetectionTypes")]
        /// Type of planes to detect in the scene.
        ///
        /// If set, new planes will continue to be detected and updated over time. Detected planes will be added to the session as
        /// ARPlaneAnchor objects. In the event that two planes are merged, the newer plane will be removed. Defaults to ARPlaneDetectionNone.
        #[unsafe(method(planeDetection))]
        #[unsafe(method_family = none)]
        pub unsafe fn planeDetection(&self) -> ARPlaneDetection;

        #[cfg(feature = "ARPlaneDetectionTypes")]
        /// Setter for [`planeDetection`][Self::planeDetection].
        #[unsafe(method(setPlaneDetection:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setPlaneDetection(&self, plane_detection: ARPlaneDetection);

        #[cfg(all(feature = "ARReferenceImage", feature = "objc2-foundation"))]
        /// Images to detect in the scene.
        ///
        /// If set the session will attempt to detect the specified images. When an image is detected an ARImageAnchor will be added to the session.
        #[unsafe(method(detectionImages))]
        #[unsafe(method_family = none)]
        pub unsafe fn detectionImages(&self) -> Retained<NSSet<ARReferenceImage>>;

        #[cfg(all(feature = "ARReferenceImage", feature = "objc2-foundation"))]
        /// Setter for [`detectionImages`][Self::detectionImages].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setDetectionImages:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDetectionImages(&self, detection_images: Option<&NSSet<ARReferenceImage>>);

        /// Enables the estimation of a scale factor which may be used to correct the physical size of an image.
        ///
        /// If set to true ARKit will attempt to use the computed camera positions in order to compute the scale by which the given physical size
        /// differs from the estimated one. The information about the estimated scale can be found as the property estimatedScaleFactor on the ARImageAnchor.
        ///
        /// Note: When set to true the transform of a returned ARImageAnchor will use the estimated scale factor to correct the translation. Default value is NO.
        #[unsafe(method(automaticImageScaleEstimationEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn automaticImageScaleEstimationEnabled(&self) -> bool;

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

        /// Maximum number of images to track simultaneously.
        ///
        /// Setting the maximum number of tracked images will limit the number of images that can be tracked in a given frame.
        /// If more than the maximum is visible, only the images already being tracked will continue to track until tracking is lost or another image is removed.
        /// Images will continue to be detected regardless of images tracked. Default value is zero.
        #[unsafe(method(maximumNumberOfTrackedImages))]
        #[unsafe(method_family = none)]
        pub unsafe fn maximumNumberOfTrackedImages(&self) -> NSInteger;

        /// Setter for [`maximumNumberOfTrackedImages`][Self::maximumNumberOfTrackedImages].
        #[unsafe(method(setMaximumNumberOfTrackedImages:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setMaximumNumberOfTrackedImages(
            &self,
            maximum_number_of_tracked_images: NSInteger,
        );

        #[cfg(all(feature = "ARReferenceObject", feature = "objc2-foundation"))]
        /// Objects to detect in the scene.
        ///
        /// If set the session will attempt to detect the specified objects. When an object is detected an ARObjectAnchor will be added to the
        /// session.
        #[unsafe(method(detectionObjects))]
        #[unsafe(method_family = none)]
        pub unsafe fn detectionObjects(&self) -> Retained<NSSet<ARReferenceObject>>;

        #[cfg(all(feature = "ARReferenceObject", feature = "objc2-foundation"))]
        /// Setter for [`detectionObjects`][Self::detectionObjects].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setDetectionObjects:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDetectionObjects(&self, detection_objects: &NSSet<ARReferenceObject>);

        /// Enable or disable app clip code tracking. Disabled by default. When enabled, detected app clip codes will be surfaced as an ARAppClipCodeAnchor.
        #[unsafe(method(appClipCodeTrackingEnabled))]
        #[unsafe(method_family = none)]
        pub unsafe fn appClipCodeTrackingEnabled(&self) -> bool;

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

        /// Indicates whether app clip code tracking can be enabled on this device.
        #[unsafe(method(supportsAppClipCodeTracking))]
        #[unsafe(method_family = none)]
        pub unsafe fn supportsAppClipCodeTracking() -> bool;

        #[cfg(all(feature = "block2", feature = "objc2-foundation"))]
        /// Determines the availability of geo tracking at the current location.
        ///
        ///
        /// This method will attempt to acquire a location fix on a background thread, then check availability.
        ///
        ///
        /// Parameter `completionHandler`: Completion handler that is called when availability has been determined. This handler is executed on an arbitrary serial
        /// queue. It takes the following parameters: isAvailable - True if geo tracking is available at the current location, otherwise false. error - An error
        /// that indicates why geo tracking is not available at the current location.
        #[unsafe(method(checkAvailabilityWithCompletionHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn checkAvailabilityWithCompletionHandler(
            completion_handler: &block2::DynBlock<dyn Fn(Bool, *mut NSError)>,
        );

        #[cfg(all(
            feature = "block2",
            feature = "objc2-core-location",
            feature = "objc2-foundation"
        ))]
        /// Determines the availability of geo tracking at the given location.
        ///
        /// Parameter `coordinate`: Location at which to check.
        ///
        /// Parameter `completionHandler`: Completion handler that is called when availability has been determined. This handler is executed on an arbitrary serial
        /// queue. It takes the following parameters: isAvailable - True if geo tracking is available at the given location, otherwise false. error - An error
        /// that indicates why geo tracking is not available at the given location.
        #[unsafe(method(checkAvailabilityAtCoordinate:completionHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn checkAvailabilityAtCoordinate_completionHandler(
            coordinate: CLLocationCoordinate2D,
            completion_handler: &block2::DynBlock<dyn Fn(Bool, *mut NSError)>,
        );

        #[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>;
    );
}