arkit.cs

//
// ARKit bindings
//
// Authors:
//	Vincent Dondain  <vidondai@microsoft.com>
//
// Copyright 2017 Microsoft Inc. All rights reserved.
//

using System;
using System.ComponentModel;
using AVFoundation;
using CoreFoundation;
using CoreGraphics;
using CoreMedia;
using CoreLocation;
using CoreVideo;
using Foundation;
using ObjCRuntime;
using ImageIO;
using Metal;
using QuickLook;
using SpriteKit;
using SceneKit;
using UIKit;

using Vector2 = global::OpenTK.Vector2;
using Vector3 = global::OpenTK.NVector3;
using Matrix3 = global::OpenTK.NMatrix3;
using Matrix4 = global::OpenTK.NMatrix4;

namespace ARKit {

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Native]
	public enum ARTrackingState : long {
		NotAvailable,
		Limited,
		Normal,
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Native]
	public enum ARTrackingStateReason : long {
		None,
		Initializing,
		ExcessiveMotion,
		InsufficientFeatures,
		[iOS (11,3)]
		Relocalizing,
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[ErrorDomain ("ARErrorDomain")]
	[Native]
	public enum ARErrorCode : long {
		UnsupportedConfiguration = 100,
		SensorUnavailable = 101,
		SensorFailed = 102,
		CameraUnauthorized = 103,
		WorldTrackingFailed = 200,
		InvalidReferenceImage = 300,
		InvalidReferenceObject = 301,
		InvalidWorldMap = 302,
		InvalidConfiguration = 303,
		#if !XAMCORE_4_0
		[Obsolete ("Please use the 'InvalidCollaborationData' value instead.")]
		CollaborationDataUnavailable = InvalidCollaborationData,
		#endif
		InvalidCollaborationData = 304,
		InsufficientFeatures = 400,
		ObjectMergeFailed = 401,
		FileIOFailed = 500,
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Flags]
	[Native]
	public enum ARHitTestResultType : ulong {
		FeaturePoint = 1 << 0,
		EstimatedHorizontalPlane = 1 << 1,
		[iOS (11,3)]
		EstimatedVerticalPlane = 1 << 2,
		ExistingPlane = 1 << 3,
		ExistingPlaneUsingExtent = 1 << 4,
		[iOS (11,3)]
		ExistingPlaneUsingGeometry = 1 << 5,
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Native]
	public enum ARPlaneAnchorAlignment : long {
		Horizontal,
		[iOS (11,3)]
		Vertical,
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Flags]
	[Native]
	public enum ARSessionRunOptions : ulong {
		None = 0,
		ResetTracking = 1 << 0,
		RemoveExistingAnchors = 1 << 1,
		StopTrackedRaycasts = 1 << 2,
		[iOS (13,4)]
		ResetSceneReconstruction = (1 << 3),
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Native]
	public enum ARWorldAlignment : long {
		Gravity,
		GravityAndHeading,
		Camera,
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Flags]
	[Native]
	public enum ARPlaneDetection : ulong {
		None = 0,
		Horizontal = 1 << 0,
		[iOS (11,3)]
		Vertical = 1 << 1,
	}

	[iOS (12,0)]
	[NoWatch, NoTV, NoMac]
	[Native]
	public enum AREnvironmentTexturing : long {
		None,
		Manual,
		Automatic,
	}

	[iOS (12,0)]
	[NoWatch, NoTV, NoMac]
	[Native]
	public enum ARWorldMappingStatus : long {
		NotAvailable,
		Limited,
		Extending,
		Mapped,
	}

	[iOS (12,0)]
	[NoWatch, NoTV, NoMac]
	[Native]
	public enum ARPlaneClassificationStatus : long {
		NotAvailable = 0,
		Undetermined,
		Unknown,
		Known,
	}

	[iOS (12,0)]
	[NoWatch, NoTV, NoMac]
	[Native]
	public enum ARPlaneClassification : long {
		None = 0,
		Wall,
		Floor,
		Ceiling,
		Table,
		Seat,
		[iOS (13,0)]
		Window,
		[iOS (13,0)]
		Door,
	}

	[iOS (13,0)]
	[Native]
	public enum ARCoachingGoal : long {
		Tracking,
		HorizontalPlane,
		VerticalPlane,
		AnyPlane,
	}

	[iOS (13,0)]
	[Flags]
	[Native]
	public enum ARFrameSemantics : long {
		None = 0x0,
		PersonSegmentation = 1 << 0,
		PersonSegmentationWithDepth = (1 << 1) | (1 << 0),
		BodyDetection = 1 << 2,
		[iOS (14,0)]
		SceneDepth = (1 << 4),
	}

	[iOS (13,0)]
	[Native]
	public enum ARMatteResolution : long {
		Full = 0,
		Half = 1,
	}

	[iOS (13,0)]
	[Native]
	public enum ARRaycastTarget : long {
		ExistingPlaneGeometry,
		ExistingPlaneInfinite,
		EstimatedPlane,
	}

	[iOS (13,0)]
	[Native]
	public enum ARRaycastTargetAlignment : long {
		Horizontal,
		Vertical,
		Any,
	}

	[iOS (13,0)]
	public enum ARSegmentationClass : byte {
		None = 0,
		Person = 255,
	}

	[iOS (13,0)]
	[Native]
	public enum ARCollaborationDataPriority : long {
		Critical,
		Optional,
	}


	[iOS (14, 0)]
	[Native]
	public enum ARAltitudeSource : long {
		Unknown,
		Coarse,
		Precise,
		UserDefined,
	}

	[iOS (14, 0)]
	[Native]
	public enum ARConfidenceLevel : long {
		Low,
		Medium,
		High,
	}

	[iOS (14, 0)]
	[Native]
	public enum ARGeoTrackingAccuracy : long {
		Undetermined,
		Low,
		Medium,
		High,
	}

	[iOS (14, 0)]
	[Native]
	public enum ARGeoTrackingState : long {
		NotAvailable,
		Initializing,
		Localizing,
		Localized,
	}

	[iOS (14, 0)]
	[Native]
	public enum ARGeoTrackingStateReason : long {
		None,
		NotAvailableAtLocation,
		NeedLocationPermissions,
		WorldTrackingUnstable,
		WaitingForLocation,
		WaitingForAvailabilityCheck,
		GeoDataNotLoaded,
		DevicePointedTooLow,
		VisualLocalizationFailed,
	}

	[iOS (12,0)]
	[NoWatch, NoTV, NoMac]
	[Protocol]
	[Advice ("To conform to 'ARAnchorCopying' you need to implement:\n'[Export (\"initWithAnchor:\")]'\n'public YourConstructor (ARAnchor anchor)'")]
	interface ARAnchorCopying : NSCopying {
		// Constructors in interfaces are not possible in C#
		// @required -(instancetype _Nonnull)initWithAnchor:(ARAnchor * _Nonnull)anchor;
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface ARAnchor : ARAnchorCopying, NSSecureCoding {

		[Export ("identifier")]
		NSUuid Identifier { get; }

		[iOS (12,0)]
		[NullAllowed, Export ("name")]
		string Name { get; }

		[iOS (13,0)]
		[NullAllowed, Export ("sessionIdentifier")]
		NSUuid SessionIdentifier { get; }

		[Export ("transform")]
		Matrix4 Transform {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("initWithTransform:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		IntPtr Constructor (Matrix4 transform);

		[iOS (12,0)]
		[Export ("initWithName:transform:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		IntPtr Constructor (string name, Matrix4 transform);

		// Inlined from 'ARAnchorCopying' protocol (we can't have constructors in interfaces)
		[iOS (12,0)]
		[Export ("initWithAnchor:")]
		IntPtr Constructor (ARAnchor anchor);
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface ARCamera : NSCopying {

		[Export ("transform")]
		Matrix4 Transform {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("eulerAngles")]
		Vector3 EulerAngles {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("trackingState")]
		ARTrackingState TrackingState { get; }

		[Export ("trackingStateReason")]
		ARTrackingStateReason TrackingStateReason { get; }

		[Export ("intrinsics")]
		Matrix3 Intrinsics {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("imageResolution")]
		CGSize ImageResolution { get; }

		[iOS (13,0)]
		[Export ("exposureDuration")]
		double ExposureDuration { get; }

		[iOS (13,0)]
		[Export ("exposureOffset")]
		float ExposureOffset { get; }

		[Export ("projectionMatrix")]
		Matrix4 ProjectionMatrix {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

#if !XAMCORE_4_0
		[Obsolete ("Use 'Project' instead.")]
		[Wrap ("Project (point, orientation, viewportSize)", IsVirtual = true)]
		CGPoint GetProjectPoint (Vector3 point, UIInterfaceOrientation orientation, CGSize viewportSize);
#endif

		[Export ("projectPoint:orientation:viewportSize:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		CGPoint Project (Vector3 point, UIInterfaceOrientation orientation, CGSize viewportSize);

		[iOS (12,0)]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		[Export ("unprojectPoint:ontoPlaneWithTransform:orientation:viewportSize:")]
		Vector3 Unproject (CGPoint point, Matrix4 planeTransform, UIInterfaceOrientation orientation, CGSize viewportSize);

		[Export ("projectionMatrixForOrientation:viewportSize:zNear:zFar:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		Matrix4 GetProjectionMatrix (UIInterfaceOrientation orientation, CGSize viewportSize, nfloat zNear, nfloat zFar);

		[Export ("viewMatrixForOrientation:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		Matrix4 GetViewMatrix (UIInterfaceOrientation orientation);
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface ARFrame : NSCopying {

		[Export ("timestamp")]
		double Timestamp { get; }

		[Export ("capturedImage")]
		CVPixelBuffer CapturedImage { get; }

		[iOS (13,0)]
		[NullAllowed, Export ("cameraGrainTexture")]
		IMTLTexture CameraGrainTexture { get; }

		[iOS (13,0)]
		[Export ("cameraGrainIntensity")]
		float CameraGrainIntensity { get; }

		[NullAllowed, Export ("capturedDepthData", ArgumentSemantic.Strong)]
		AVDepthData CapturedDepthData { get; }

		[Export ("capturedDepthDataTimestamp")]
		double CapturedDepthDataTimestamp { get; }

		[Export ("camera", ArgumentSemantic.Copy)]
		ARCamera Camera { get; }

		[Export ("anchors", ArgumentSemantic.Copy)]
		ARAnchor[] Anchors { get; }

		[NullAllowed, Export ("lightEstimate", ArgumentSemantic.Strong)]
		ARLightEstimate LightEstimate { get; }

		[NullAllowed, Export ("rawFeaturePoints", ArgumentSemantic.Strong)]
		ARPointCloud RawFeaturePoints { get; }

		[iOS (12,0)]
		[Export ("worldMappingStatus")]
		ARWorldMappingStatus WorldMappingStatus { get; }

		[iOS (13,0)]
		[NullAllowed, Export ("segmentationBuffer")]
		CVPixelBuffer SegmentationBuffer { get; }

		[iOS (13,0)]
		[NullAllowed, Export ("estimatedDepthData")]
		CVPixelBuffer EstimatedDepthData { get; }

		[iOS (13,0)]
		[NullAllowed, Export ("detectedBody")]
		ARBody2D DetectedBody { get; }

		[Deprecated (PlatformName.iOS, 14, 0, message: "Use 'ARSession.Raycast' instead.")]
		[Export ("hitTest:types:")]
		ARHitTestResult[] HitTest (CGPoint point, ARHitTestResultType types);

		[iOS (13,0)]
		[Export ("raycastQueryFromPoint:allowingTarget:alignment:")]
		ARRaycastQuery CreateRaycastQuery (CGPoint point, ARRaycastTarget target, ARRaycastTargetAlignment alignment);

		[Export ("displayTransformForOrientation:viewportSize:")]
		CGAffineTransform GetDisplayTransform (UIInterfaceOrientation orientation, CGSize viewportSize);

		[iOS (14, 0)]
		[NullAllowed, Export ("geoTrackingStatus", ArgumentSemantic.Strong)]
		ARGeoTrackingStatus GeoTrackingStatus { get; }

		[iOS (14, 0)]
		[NullAllowed, Export ("sceneDepth", ArgumentSemantic.Strong)]
		ARDepthData SceneDepth { get; }

		[iOS (14, 0)]
		[NullAllowed]
		[Export ("smoothedSceneDepth", ArgumentSemantic.Strong)]
		ARDepthData SmoothedSceneDepth { get; }
	}

	[iOS (11,0)]
	[Deprecated (PlatformName.iOS, 14, 0, message: "Use Raycasting methods over HitTestResult ones.")]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface ARHitTestResult {

		[Export ("type")]
		ARHitTestResultType Type { get; }

		[Export ("distance")]
		nfloat Distance { get; }

		[Export ("localTransform")]
		Matrix4 LocalTransform {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("worldTransform")]
		Matrix4 WorldTransform {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[NullAllowed, Export ("anchor", ArgumentSemantic.Strong)]
		ARAnchor Anchor { get; }
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface ARLightEstimate {

		[Export ("ambientIntensity")]
		nfloat AmbientIntensity { get; }

		[Export ("ambientColorTemperature")]
		nfloat AmbientColorTemperature { get; }
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (ARAnchor))]
	[DisableDefaultCtor]
	interface ARPlaneAnchor {
		// Inlined from 'ARAnchorCopying' protocol (we can't have constructors in interfaces)
		[iOS (12,0)]
		[Export ("initWithAnchor:")]
		IntPtr Constructor (ARAnchor anchor);

		// [Export ("initWithTransform:")] marked as NS_UNAVAILABLE

		[iOS (12,0)]
		[Static]
		[Export ("classificationSupported")]
		bool ClassificationSupported { [Bind ("isClassificationSupported")] get; }

		[Export ("alignment")]
		ARPlaneAnchorAlignment Alignment { get; }

		[Export ("center")]
		Vector3 Center {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("extent")]
		Vector3 Extent {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[iOS (11,3)]
		[Export ("geometry", ArgumentSemantic.Strong)]
		ARPlaneGeometry Geometry { get; }

		[iOS (12,0)]
		[Export ("classificationStatus", ArgumentSemantic.Assign)]
		ARPlaneClassificationStatus ClassificationStatus { get; }

		[iOS (12,0)]
		[Export ("classification", ArgumentSemantic.Assign)]
		ARPlaneClassification Classification { get; }
	}

	[iOS (11,3)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARPlaneGeometry : NSSecureCoding {
		[Export ("vertexCount")]
		nuint VertexCount { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("vertices")]
		IntPtr GetRawVertices ();

		[Export ("textureCoordinateCount")]
		nuint TextureCoordinateCount { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("textureCoordinates")]
		IntPtr GetRawTextureCoordinates ();

		[Export ("triangleCount")]
		nuint TriangleCount { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("triangleIndices")]
		IntPtr GetRawTriangleIndices ();

		[Export ("boundaryVertexCount")]
		nuint BoundaryVertexCount { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("boundaryVertices")]
		IntPtr GetRawBoundaryVertices ();
	}

	[iOS (11,3)]
	[BaseType (typeof(SCNGeometry))]
	[DisableDefaultCtor]
	interface ARSCNPlaneGeometry {
		[Static]
		[Export ("planeGeometryWithDevice:")]
		[return: NullAllowed]
		ARSCNPlaneGeometry Create (IMTLDevice device);

		[Export ("updateFromPlaneGeometry:")]
		void Update (ARPlaneGeometry planeGeometry);
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface ARPointCloud : NSSecureCoding {

		[Export ("count")]
		nuint Count { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Protected, Export ("points")]
		IntPtr GetRawPoints ();

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Protected, Export ("identifiers")]
		IntPtr GetRawIdentifiers ();
	}

	[iOS (11,3)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARReferenceImage : NSCopying {
		[NullAllowed, Export ("name")]
		string Name { get; set; }

		[Export ("physicalSize")]
		CGSize PhysicalSize { get; }

		[iOS (13,0)]
		[NullAllowed, Export ("resourceGroupName", ArgumentSemantic.Strong)]
		string ResourceGroupName { get; }

		[iOS (13,0)]
		[Async]
		[Export ("validateWithCompletionHandler:")]
		void Validate (Action<NSError> completionHandler);

		[Export ("initWithCGImage:orientation:physicalWidth:")]
		IntPtr Constructor (CGImage image, CGImagePropertyOrientation orientation, nfloat physicalWidth);

		[Export ("initWithPixelBuffer:orientation:physicalWidth:")]
		IntPtr Constructor (CVPixelBuffer pixelBuffer, CGImagePropertyOrientation orientation, nfloat physicalWidth);

		[Static]
		[Export ("referenceImagesInGroupNamed:bundle:")]
		[return: NullAllowed]
		NSSet<ARReferenceImage> GetReferenceImagesInGroup (string name, [NullAllowed] NSBundle bundle);
	}

	[iOS (11,3)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARVideoFormat : NSCopying {

		[iOS (13,0)]
		[Export ("captureDevicePosition")]
		AVCaptureDevicePosition CaptureDevicePosition { get; }

		[Export ("imageResolution")]
		CGSize ImageResolution { get; }

		[Export ("framesPerSecond")]
		nint FramesPerSecond { get; }
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (SCNView))]
	interface ARSCNView : ARSessionProviding {

		[NullAllowed, Export ("delegate", ArgumentSemantic.Weak)]
		IARSCNViewDelegate Delegate { get; set; }

		// We get the Session property from ARSessionProviding, but only the getter, so we must redefine the property here.
		[Export ("session", ArgumentSemantic.Strong)]
		new ARSession Session { get; set; }

		[Export ("scene", ArgumentSemantic.Strong)]
		SCNScene Scene { get; set; }

		[Export ("automaticallyUpdatesLighting")]
		bool AutomaticallyUpdatesLighting { get; set; }

		[iOS (13,0)]
		[Export ("rendersCameraGrain")]
		bool RendersCameraGrain { get; set; }

		[iOS (13,0)]
		[Export ("rendersMotionBlur")]
		bool RendersMotionBlur { get; set; }

		[Export ("anchorForNode:")]
		[return: NullAllowed]
		ARAnchor GetAnchor (SCNNode node);

		[Export ("nodeForAnchor:")]
		[return: NullAllowed]
		SCNNode GetNode (ARAnchor anchor);

		[Export ("hitTest:types:")]
		[Deprecated (PlatformName.iOS, 14, 0, message: "Use 'CreateRaycastQuery' instead.")]
		ARHitTestResult[] HitTest (CGPoint point, ARHitTestResultType types);

		[iOS (12,0)]
		[Export ("unprojectPoint:ontoPlaneWithTransform:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		Vector3 Unproject (CGPoint point, Matrix4 planeTransform);

		[iOS (13,0)]
		[Export ("raycastQueryFromPoint:allowingTarget:alignment:")]
		[return: NullAllowed]
		ARRaycastQuery CreateRaycastQuery (CGPoint point, ARRaycastTarget target, ARRaycastTargetAlignment alignment);
	}

	interface IARSCNViewDelegate {}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Protocol, Model]
	[BaseType (typeof (NSObject))]
	interface ARSCNViewDelegate : SCNSceneRendererDelegate, ARSessionObserver {

		[Export ("renderer:nodeForAnchor:")]
		[return: NullAllowed]
		SCNNode GetNode (ISCNSceneRenderer renderer, ARAnchor anchor);

		[Export ("renderer:didAddNode:forAnchor:")]
		void DidAddNode (ISCNSceneRenderer renderer, SCNNode node, ARAnchor anchor);

		[Export ("renderer:willUpdateNode:forAnchor:")]
		void WillUpdateNode (ISCNSceneRenderer renderer, SCNNode node, ARAnchor anchor);

		[Export ("renderer:didUpdateNode:forAnchor:")]
		void DidUpdateNode (ISCNSceneRenderer renderer, SCNNode node, ARAnchor anchor);

		[Export ("renderer:didRemoveNode:forAnchor:")]
		void DidRemoveNode (ISCNSceneRenderer renderer, SCNNode node, ARAnchor anchor);
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (SKView))]
	interface ARSKView : ARSessionProviding {

		[NullAllowed, Export ("delegate", ArgumentSemantic.Weak)]
		IARSKViewDelegate Delegate { get; set; }

		// We get the Session property from ARSessionProviding, but only the getter, so we must redefine the property here.
		[Export ("session", ArgumentSemantic.Strong)]
		new ARSession Session { get; set; }

		[Export ("anchorForNode:")]
		[return: NullAllowed]
		ARAnchor GetAnchor (SKNode node);

		[Export ("nodeForAnchor:")]
		[return: NullAllowed]
		SKNode GetNode (ARAnchor anchor);

		[Deprecated (PlatformName.iOS, 14, 0, message: "Use Raycasting methods instead.")]
		[Export ("hitTest:types:")]
		ARHitTestResult[] HitTest (CGPoint point, ARHitTestResultType types);
	}

	interface IARSKViewDelegate {}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Protocol, Model]
	[BaseType (typeof (NSObject))]
	interface ARSKViewDelegate : SKViewDelegate, ARSessionObserver {

		[Export ("view:nodeForAnchor:")]
		[return: NullAllowed]
		SKNode GetNode (ARSKView view, ARAnchor anchor);

		[Export ("view:didAddNode:forAnchor:")]
		void DidAddNode (ARSKView view, SKNode node, ARAnchor anchor);

		[Export ("view:willUpdateNode:forAnchor:")]
		void WillUpdateNode (ARSKView view, SKNode node, ARAnchor anchor);

		[Export ("view:didUpdateNode:forAnchor:")]
		void DidUpdateNode (ARSKView view, SKNode node, ARAnchor anchor);

		[Export ("view:didRemoveNode:forAnchor:")]
		void DidRemoveNode (ARSKView view, SKNode node, ARAnchor anchor);
	}

	delegate void GetGeolocationCallback (CLLocationCoordinate2D coordinate, double altitude, NSError error);

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (NSObject))]
	interface ARSession {

		[iOS (13,0)]
		[Export ("identifier", ArgumentSemantic.Strong)]
		NSUuid Identifier { get; }

		[NullAllowed, Export ("delegate", ArgumentSemantic.Weak)]
		IARSessionDelegate Delegate { get; set; }

		[NullAllowed, Export ("delegateQueue", ArgumentSemantic.Strong)]
		DispatchQueue DelegateQueue { get; set; }

		[NullAllowed, Export ("currentFrame", ArgumentSemantic.Copy)]
		ARFrame CurrentFrame { get; }

		[NullAllowed, Export ("configuration", ArgumentSemantic.Copy)]
		ARConfiguration Configuration { get; }

		[Export ("runWithConfiguration:")]
		void Run (ARConfiguration configuration);

		[Export ("runWithConfiguration:options:")]
		void Run (ARConfiguration configuration, ARSessionRunOptions options);

		[Export ("pause")]
		void Pause ();

		[Export ("addAnchor:")]
		void AddAnchor (ARAnchor anchor);

		[Export ("removeAnchor:")]
		void RemoveAnchor (ARAnchor anchor);

		[iOS (11,3)]
		[Export ("setWorldOrigin:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		void SetWorldOrigin (Matrix4 relativeTransform);

		[iOS (12,0)]
		[Async]
		[Export ("getCurrentWorldMapWithCompletionHandler:")]
		void GetCurrentWorldMap (Action<ARWorldMap, NSError> completionHandler);

		[iOS (12,0)]
		[Async]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		[Export ("createReferenceObjectWithTransform:center:extent:completionHandler:")]
		void CreateReferenceObject (Matrix4 transform, Vector3 center, Vector3 extent, Action<ARReferenceObject, NSError> completionHandler);

		[iOS (13,0)]
		[Export ("raycast:")]
		ARRaycastResult[] Raycast (ARRaycastQuery query);

		[iOS (13,0)]
		[Async]
		[Export ("trackedRaycast:updateHandler:")]
		[return: NullAllowed]
		ARTrackedRaycast TrackedRaycast (ARRaycastQuery query, Action<ARRaycastResult[]> updateHandler);

		[iOS (13,0)]
		[Export ("updateWithCollaborationData:")]
		void Update (ARCollaborationData collaborationData);

		[iOS (14, 0)]
		[Async (ResultTypeName="GeoLocationForPoint")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		[Export ("getGeoLocationForPoint:completionHandler:")]
		void GetGeoLocation (Vector3 position, GetGeolocationCallback completionHandler);
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Protocol]
	interface ARSessionObserver {

		[Export ("session:didFailWithError:")]
		void DidFail (ARSession session, NSError error);

		[Export ("session:cameraDidChangeTrackingState:")]
		void CameraDidChangeTrackingState (ARSession session, ARCamera camera);

		[Export ("sessionWasInterrupted:")]
		void WasInterrupted (ARSession session);

		[Export ("sessionInterruptionEnded:")]
		void InterruptionEnded (ARSession session);

		[iOS (11,3)]
		[Export ("sessionShouldAttemptRelocalization:")]
		bool ShouldAttemptRelocalization (ARSession session);

		[Export ("session:didOutputAudioSampleBuffer:")]
		void DidOutputAudioSampleBuffer (ARSession session, CMSampleBuffer audioSampleBuffer);

		[iOS (13,0)]
		[Export ("session:didOutputCollaborationData:")]
		void DidOutputCollaborationData (ARSession session, ARCollaborationData data);

		[iOS (14, 0)]
		[Export ("session:didChangeGeoTrackingStatus:")]
		void DidChangeGeoTrackingStatus (ARSession session, ARGeoTrackingStatus geoTrackingStatus);
	}

	interface IARSessionDelegate {}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Protocol, Model]
	[BaseType (typeof (NSObject))]
	interface ARSessionDelegate : ARSessionObserver {

		[Export ("session:didUpdateFrame:")]
		void DidUpdateFrame (ARSession session, ARFrame frame);

		[Export ("session:didAddAnchors:")]
		void DidAddAnchors (ARSession session, ARAnchor[] anchors);

		[Export ("session:didUpdateAnchors:")]
		void DidUpdateAnchors (ARSession session, ARAnchor[] anchors);

		[Export ("session:didRemoveAnchors:")]
		void DidRemoveAnchors (ARSession session, ARAnchor[] anchors);
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (NSObject))]
	[Abstract]
	[DisableDefaultCtor]
	interface ARConfiguration : NSCopying {

		[Static]
		[Export ("isSupported")]
		bool IsSupported { get; }

#if !XAMCORE_4_0
		// even if static - it's abstract
		[iOS (11,3)]
		[Static]
		[Obsolete ("This is an abstract static method. You need to call 'GetSupportedVideoFormats ()' from a subclass to get results.")]
		ARVideoFormat[] SupportedVideoFormats {
			// avoid the native exception leading to a crash
			[Wrap ("Array.Empty<ARVideoFormat> ()")]
			get;
		}
#endif

		[iOS (11,3)]
		[Export ("videoFormat", ArgumentSemantic.Strong)]
		ARVideoFormat VideoFormat { get; set; }

		[Export ("worldAlignment", ArgumentSemantic.Assign)]
		ARWorldAlignment WorldAlignment { get; set; }

		[Export ("lightEstimationEnabled")]
		bool LightEstimationEnabled { [Bind ("isLightEstimationEnabled")] get; set; }

		[Export ("providesAudioData")]
		bool ProvidesAudioData { get; set; }

		[iOS (13,0)]
		[Export ("frameSemantics", ArgumentSemantic.Assign)]
		ARFrameSemantics FrameSemantics { get; set; }

		[iOS (13,0)]
		[Static]
		[Export ("supportsFrameSemantics:")]
		bool SupportsFrameSemantics (ARFrameSemantics frameSemantics);
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof (ARConfiguration))]
	interface ARWorldTrackingConfiguration {

		[iOS (11,3)]
		[Static]
		[Export ("supportedVideoFormats")]
		ARVideoFormat[] GetSupportedVideoFormats ();

		[iOS (11,3)]
		[Export ("autoFocusEnabled")]
		bool AutoFocusEnabled { [Bind ("isAutoFocusEnabled")] get; set; }

		[iOS (12,0)]
		[Export ("environmentTexturing", ArgumentSemantic.Assign)]
		AREnvironmentTexturing EnvironmentTexturing { get; set; }

		[iOS (13,0)]
		[Export ("wantsHDREnvironmentTextures")]
		bool WantsHdrEnvironmentTextures { get; set; }

		[Export ("planeDetection", ArgumentSemantic.Assign)]
		ARPlaneDetection PlaneDetection { get; set; }

		[iOS (12,0)]
		[NullAllowed, Export ("initialWorldMap", ArgumentSemantic.Strong)]
		ARWorldMap InitialWorldMap { get; set; }

		[iOS (11,3)]
		[NullAllowed] //null_resettable
		[Export ("detectionImages", ArgumentSemantic.Copy)]
		NSSet<ARReferenceImage> DetectionImages { get; set; }

		[iOS (13,0)]
		[Export ("automaticImageScaleEstimationEnabled")]
		bool AutomaticImageScaleEstimationEnabled { get; set; }

		[iOS (12,0)]
		[Export ("maximumNumberOfTrackedImages")]
		nint MaximumNumberOfTrackedImages { get; set; }

		[iOS (12,0)]
		[Export ("detectionObjects", ArgumentSemantic.Copy)]
		NSSet<ARReferenceObject> DetectionObjects { get; set; }

		[iOS (13,0)]
		[Export ("collaborationEnabled")]
		bool CollaborationEnabled { [Bind ("isCollaborationEnabled")] get; set; }

		[iOS (13,0)]
		[Static]
		[Export ("supportsUserFaceTracking")]
		bool SupportsUserFaceTracking { get; }

		[iOS (13,0)]
		[Export ("userFaceTrackingEnabled")]
		bool UserFaceTrackingEnabled { [Bind ("userFaceTrackingEnabled")] get; set; }

		[iOS (13,4)]
		[Static]
		[Export ("supportsSceneReconstruction:")]
		bool SupportsSceneReconstruction (ARSceneReconstruction sceneReconstruction);

		[iOS (13,4)]
		[Export ("sceneReconstruction", ArgumentSemantic.Assign)]
		ARSceneReconstruction SceneReconstruction { get; set; }

		[iOS (13,0)]
		[Static]
		[Export ("supportsFrameSemantics:")]
		bool SupportsFrameSemantics (ARFrameSemantics frameSemantics);
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(ARConfiguration))]
	interface AROrientationTrackingConfiguration {

		[iOS (11,3)]
		[Static]
		[Export ("supportedVideoFormats")]
		ARVideoFormat[] GetSupportedVideoFormats ();

		[iOS (11,3)]
		[Export ("autoFocusEnabled")]
		bool AutoFocusEnabled { [Bind ("isAutoFocusEnabled")] get; set; }

		[iOS (13,0)]
		[Static]
		[Export ("supportsFrameSemantics:")]
		bool SupportsFrameSemantics (ARFrameSemantics frameSemantics);
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Static]
	interface ARSCNDebugOptions {

		[Field ("ARSCNDebugOptionShowWorldOrigin")]
		SCNDebugOptions ShowWorldOrigin { get; }

		[Field ("ARSCNDebugOptionShowFeaturePoints")]
		SCNDebugOptions ShowFeaturePoints { get; }
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Protocol]
	interface ARTrackable {
		[Abstract]
		[Export ("isTracked")]
		bool IsTracked { get; }
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(ARConfiguration))]
	interface ARFaceTrackingConfiguration {
		[iOS (11,3)]
		[Static]
		[Export ("supportedVideoFormats")]
		ARVideoFormat[] GetSupportedVideoFormats ();

		[iOS (13,0)]
		[Static]
		[Export ("supportedNumberOfTrackedFaces")]
		nint SupportedNumberOfTrackedFaces { get; }

		[iOS (13,0)]
		[Export ("maximumNumberOfTrackedFaces")]
		nint MaximumNumberOfTrackedFaces { get; set; }

		[iOS (13,0)]
		[Static]
		[Export ("supportsWorldTracking")]
		bool SupportsWorldTracking { get; }

		[iOS (13,0)]
		[Export ("worldTrackingEnabled")]
		bool WorldTrackingEnabled { [Bind ("isWorldTrackingEnabled")] get; set; }

		[iOS (13,0)]
		[Static]
		[Export ("supportsFrameSemantics:")]
		bool SupportsFrameSemantics (ARFrameSemantics frameSemantics);
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[StrongDictionary ("ARBlendShapeLocationKeys")]
	interface ARBlendShapeLocationOptions {

		float BrowDownLeft { get; set; }

		float BrowDownRight { get; set; }

		float BrowInnerUp { get; set; }

		float BrowOuterUpLeft { get; set; }

		float BrowOuterUpRight { get; set; }

		float CheekPuff { get; set; }

		float CheekSquintLeft { get; set; }

		float CheekSquintRight { get; set; }

		float EyeBlinkLeft { get; set; }

		float EyeBlinkRight { get; set; }

		float EyeLookDownLeft { get; set; }

		float EyeLookDownRight { get; set; }

		float EyeLookInLeft { get; set; }

		float EyeLookInRight { get; set; }

		float EyeLookOutLeft { get; set; }

		float EyeLookOutRight { get; set; }

		float EyeLookUpLeft { get; set; }

		float EyeLookUpRight { get; set; }

		float EyeSquintLeft { get; set; }

		float EyeSquintRight { get; set; }

		float EyeWideLeft { get; set; }

		float EyeWideRight { get; set; }

		float JawForward { get; set; }

		float JawLeft { get; set; }

		float JawOpen { get; set; }

		float JawRight { get; set; }

		float MouthClose { get; set; }

		float MouthDimpleLeft { get; set; }

		float MouthDimpleRight { get; set; }

		float MouthFrownLeft { get; set; }

		float MouthFrownRight { get; set; }

		float MouthFunnel { get; set; }

		float MouthLeft { get; set; }

		float MouthLowerDownLeft { get; set; }

		float MouthLowerDownRight { get; set; }

		float MouthPressLeft { get; set; }

		float MouthPressRight { get; set; }

		float MouthPucker { get; set; }

		float MouthRight { get; set; }

		float MouthRollLower { get; set; }

		float MouthRollUpper { get; set; }

		float MouthShrugLower { get; set; }

		float MouthShrugUpper { get; set; }

		float MouthSmileLeft { get; set; }

		float MouthSmileRight { get; set; }

		float MouthStretchLeft { get; set; }

		float MouthStretchRight { get; set; }

		float MouthUpperUpLeft { get; set; }

		float MouthUpperUpRight { get; set; }

		float NoseSneerLeft { get; set; }

		float NoseSneerRight { get; set; }

		[iOS (12,0)]
		float TongueOut { get; set; }
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[Static]
	[Internal]
	interface ARBlendShapeLocationKeys {

		[Field ("ARBlendShapeLocationBrowDownLeft")]
		NSString BrowDownLeftKey { get; }

		[Field ("ARBlendShapeLocationBrowDownRight")]
		NSString BrowDownRightKey { get; }

		[Field ("ARBlendShapeLocationBrowInnerUp")]
		NSString BrowInnerUpKey { get; }

		[Field ("ARBlendShapeLocationBrowOuterUpLeft")]
		NSString BrowOuterUpLeftKey { get; }

		[Field ("ARBlendShapeLocationBrowOuterUpRight")]
		NSString BrowOuterUpRightKey { get; }

		[Field ("ARBlendShapeLocationCheekPuff")]
		NSString CheekPuffKey { get; }

		[Field ("ARBlendShapeLocationCheekSquintLeft")]
		NSString CheekSquintLeftKey { get; }

		[Field ("ARBlendShapeLocationCheekSquintRight")]
		NSString CheekSquintRightKey { get; }

		[Field ("ARBlendShapeLocationEyeBlinkLeft")]
		NSString EyeBlinkLeftKey { get; }

		[Field ("ARBlendShapeLocationEyeBlinkRight")]
		NSString EyeBlinkRightKey { get; }

		[Field ("ARBlendShapeLocationEyeLookDownLeft")]
		NSString EyeLookDownLeftKey { get; }

		[Field ("ARBlendShapeLocationEyeLookDownRight")]
		NSString EyeLookDownRightKey { get; }

		[Field ("ARBlendShapeLocationEyeLookInLeft")]
		NSString EyeLookInLeftKey { get; }

		[Field ("ARBlendShapeLocationEyeLookInRight")]
		NSString EyeLookInRightKey { get; }

		[Field ("ARBlendShapeLocationEyeLookOutLeft")]
		NSString EyeLookOutLeftKey { get; }

		[Field ("ARBlendShapeLocationEyeLookOutRight")]
		NSString EyeLookOutRightKey { get; }

		[Field ("ARBlendShapeLocationEyeLookUpLeft")]
		NSString EyeLookUpLeftKey { get; }

		[Field ("ARBlendShapeLocationEyeLookUpRight")]
		NSString EyeLookUpRightKey { get; }

		[Field ("ARBlendShapeLocationEyeSquintLeft")]
		NSString EyeSquintLeftKey { get; }

		[Field ("ARBlendShapeLocationEyeSquintRight")]
		NSString EyeSquintRightKey { get; }

		[Field ("ARBlendShapeLocationEyeWideLeft")]
		NSString EyeWideLeftKey { get; }

		[Field ("ARBlendShapeLocationEyeWideRight")]
		NSString EyeWideRightKey { get; }

		[Field ("ARBlendShapeLocationJawForward")]
		NSString JawForwardKey { get; }

		[Field ("ARBlendShapeLocationJawLeft")]
		NSString JawLeftKey { get; }

		[Field ("ARBlendShapeLocationJawOpen")]
		NSString JawOpenKey { get; }

		[Field ("ARBlendShapeLocationJawRight")]
		NSString JawRightKey { get; }

		[Field ("ARBlendShapeLocationMouthClose")]
		NSString MouthCloseKey { get; }

		[Field ("ARBlendShapeLocationMouthDimpleLeft")]
		NSString MouthDimpleLeftKey { get; }

		[Field ("ARBlendShapeLocationMouthDimpleRight")]
		NSString MouthDimpleRightKey { get; }

		[Field ("ARBlendShapeLocationMouthFrownLeft")]
		NSString MouthFrownLeftKey { get; }

		[Field ("ARBlendShapeLocationMouthFrownRight")]
		NSString MouthFrownRightKey { get; }

		[Field ("ARBlendShapeLocationMouthFunnel")]
		NSString MouthFunnelKey { get; }

		[Field ("ARBlendShapeLocationMouthLeft")]
		NSString MouthLeftKey { get; }

		[Field ("ARBlendShapeLocationMouthLowerDownLeft")]
		NSString MouthLowerDownLeftKey { get; }

		[Field ("ARBlendShapeLocationMouthLowerDownRight")]
		NSString MouthLowerDownRightKey { get; }

		[Field ("ARBlendShapeLocationMouthPressLeft")]
		NSString MouthPressLeftKey { get; }

		[Field ("ARBlendShapeLocationMouthPressRight")]
		NSString MouthPressRightKey { get; }

		[Field ("ARBlendShapeLocationMouthPucker")]
		NSString MouthPuckerKey { get; }

		[Field ("ARBlendShapeLocationMouthRight")]
		NSString MouthRightKey { get; }

		[Field ("ARBlendShapeLocationMouthRollLower")]
		NSString MouthRollLowerKey { get; }

		[Field ("ARBlendShapeLocationMouthRollUpper")]
		NSString MouthRollUpperKey { get; }

		[Field ("ARBlendShapeLocationMouthShrugLower")]
		NSString MouthShrugLowerKey { get; }

		[Field ("ARBlendShapeLocationMouthShrugUpper")]
		NSString MouthShrugUpperKey { get; }

		[Field ("ARBlendShapeLocationMouthSmileLeft")]
		NSString MouthSmileLeftKey { get; }

		[Field ("ARBlendShapeLocationMouthSmileRight")]
		NSString MouthSmileRightKey { get; }

		[Field ("ARBlendShapeLocationMouthStretchLeft")]
		NSString MouthStretchLeftKey { get; }

		[Field ("ARBlendShapeLocationMouthStretchRight")]
		NSString MouthStretchRightKey { get; }

		[Field ("ARBlendShapeLocationMouthUpperUpLeft")]
		NSString MouthUpperUpLeftKey { get; }

		[Field ("ARBlendShapeLocationMouthUpperUpRight")]
		NSString MouthUpperUpRightKey { get; }

		[Field ("ARBlendShapeLocationNoseSneerLeft")]
		NSString NoseSneerLeftKey { get; }

		[Field ("ARBlendShapeLocationNoseSneerRight")]
		NSString NoseSneerRightKey { get; }

		[iOS (12,0)]
		[Field ("ARBlendShapeLocationTongueOut")]
		NSString TongueOutKey { get; }
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(ARAnchor))]
	[DisableDefaultCtor]
	interface ARFaceAnchor : ARTrackable {
		// Inlined from 'ARAnchorCopying' protocol (we can't have constructors in interfaces)
		[iOS (12,0)]
		[Export ("initWithAnchor:")]
		IntPtr Constructor (ARAnchor anchor);

#if !XAMCORE_4_0
		[Obsolete ("Constructor marked as unavailable.")]
		[Export ("init")]
		IntPtr Constructor ();
#endif

		[Export ("geometry")]
		ARFaceGeometry Geometry { get; }

		[iOS (12,0)]
		[Export ("leftEyeTransform")]
		Matrix4 LeftEyeTransform {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[iOS (12,0)]
		[Export ("rightEyeTransform")]
		Matrix4 RightEyeTransform {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[iOS (12,0)]
		[Export ("lookAtPoint")]
		Vector3 LookAtPoint {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("blendShapes")]
		NSDictionary WeakBlendShapes { get; }

		[Wrap ("WeakBlendShapes")]
		ARBlendShapeLocationOptions BlendShapes { get; }
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARFaceGeometry : NSCopying, NSSecureCoding {
		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("initWithBlendShapes:")]
		IntPtr Constructor (NSDictionary blendShapes);

		[Wrap ("this (blendShapes.GetDictionary ()!)")]
		IntPtr Constructor (ARBlendShapeLocationOptions blendShapes);

		[Export ("vertexCount")]
		nuint VertexCount { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("vertices")]
		IntPtr GetRawVertices ();

		[Export ("textureCoordinateCount")]
		nuint TextureCoordinateCount { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("textureCoordinates")]
		IntPtr GetRawTextureCoordinates ();

		[Export ("triangleCount")]
		nuint TriangleCount { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("triangleIndices")]
		IntPtr GetRawTriangleIndices ();
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(SCNGeometry))]
	[DisableDefaultCtor]
	interface ARSCNFaceGeometry {
#if !XAMCORE_4_0
		[Obsolete ("Use the 'Create' static constructor instead.")]
		[Static]
		[Wrap ("Create (device)")]
		[return: NullAllowed]
		ARSCNFaceGeometry CreateFaceGeometry (IMTLDevice device);
#endif

		[Static]
		[Export ("faceGeometryWithDevice:")]
		[return: NullAllowed]
		ARSCNFaceGeometry Create (IMTLDevice device);

#if !XAMCORE_4_0
		[Obsolete ("Use the 'Create' static constructor instead.")]
		[Static]
		[Wrap ("Create (device, fillMesh)")]
		[return: NullAllowed]
		ARSCNFaceGeometry CreateFaceGeometry (IMTLDevice device, bool fillMesh);
#endif

		[Static]
		[Export ("faceGeometryWithDevice:fillMesh:")]
		[return: NullAllowed]
		ARSCNFaceGeometry Create (IMTLDevice device, bool fillMesh);

		[Export ("updateFromFaceGeometry:")]
		void Update (ARFaceGeometry faceGeometry);
	}

	[iOS (11,3)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(ARAnchor))]
	[DisableDefaultCtor]
	interface ARImageAnchor : ARTrackable {
		// Inlined from 'ARAnchorCopying' protocol (we can't have constructors in interfaces)
		[iOS (12,0)]
		[Export ("initWithAnchor:")]
		IntPtr Constructor (ARAnchor anchor);

		[Export ("referenceImage", ArgumentSemantic.Strong)]
		ARReferenceImage ReferenceImage { get; }

		[iOS (13,0)]
		[Export ("estimatedScaleFactor")]
		nfloat EstimatedScaleFactor { get; }
	}

	[iOS (11,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(ARLightEstimate))]
	[DisableDefaultCtor]
	interface ARDirectionalLightEstimate {
		[Export ("sphericalHarmonicsCoefficients", ArgumentSemantic.Copy)]
		NSData SphericalHarmonicsCoefficients { get; }

		[Export ("primaryLightDirection")]
		Vector3 PrimaryLightDirection {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("primaryLightIntensity")]
		nfloat PrimaryLightIntensity { get; }
	}

	[iOS (12,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(ARConfiguration))]
	interface ARImageTrackingConfiguration {
		[Static]
		[Export ("supportedVideoFormats")]
		ARVideoFormat[] GetSupportedVideoFormats ();

		[Export ("autoFocusEnabled")]
		bool AutoFocusEnabled { [Bind ("isAutoFocusEnabled")] get; set; }

		[Export ("trackingImages", ArgumentSemantic.Copy)]
		NSSet<ARReferenceImage> TrackingImages { get; set; }

		[Export ("maximumNumberOfTrackedImages")]
		nint MaximumNumberOfTrackedImages { get; set; }

		[iOS (13,0)]
		[Static]
		[Export ("supportsFrameSemantics:")]
		bool SupportsFrameSemantics (ARFrameSemantics frameSemantics);
	}

	[iOS (12,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(ARConfiguration))]
	interface ARObjectScanningConfiguration {
		[Static]
		[Export ("supportedVideoFormats")]
		ARVideoFormat[] GetSupportedVideoFormats ();

		[Export ("autoFocusEnabled")]
		bool AutoFocusEnabled { [Bind ("isAutoFocusEnabled")] get; set; }

		[Export ("planeDetection", ArgumentSemantic.Assign)]
		ARPlaneDetection PlaneDetection { get; set; }

		[iOS (13,0)]
		[Static]
		[Export ("supportsFrameSemantics:")]
		bool SupportsFrameSemantics (ARFrameSemantics frameSemantics);
	}

	[iOS (12,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(ARAnchor))]
	[DisableDefaultCtor]
	interface AREnvironmentProbeAnchor {
		// Inlined from 'ARAnchorCopying' protocol (we can't have constructors in interfaces)
		[iOS (12,0)]
		[Export ("initWithAnchor:")]
		IntPtr Constructor (ARAnchor anchor);

		[Export ("initWithTransform:extent:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		IntPtr Constructor (Matrix4 transform, Vector3 extent);

		[Export ("initWithName:transform:extent:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		IntPtr Constructor (string name, Matrix4 transform, Vector3 extent);

		[NullAllowed, Export ("environmentTexture", ArgumentSemantic.Strong)]
		IMTLTexture EnvironmentTexture { get; }

		[Export ("extent")]
		Vector3 Extent {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}
	}

	[iOS (12,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARReferenceObject : NSSecureCoding {
		[Export ("initWithArchiveURL:error:")]
		IntPtr Constructor (NSUrl archiveUrl, [NullAllowed] out NSError error);

		[NullAllowed, Export ("name")]
		string Name { get; set; }

		[Export ("center")]
		Vector3 Center {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("extent")]
		Vector3 Extent {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("scale")]
		Vector3 Scale {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[iOS (13,0)]
		[NullAllowed, Export ("resourceGroupName", ArgumentSemantic.Strong)]
		string ResourceGroupName { get; }

		[Export ("rawFeaturePoints", ArgumentSemantic.Strong)]
		ARPointCloud RawFeaturePoints { get; }

		[Static]
		[Export ("referenceObjectsInGroupNamed:bundle:")]
		[return: NullAllowed]
		NSSet<ARReferenceObject> GetReferenceObjects (string resourceGroupName, [NullAllowed] NSBundle bundle);

		[Export ("exportObjectToURL:previewImage:error:")]
		bool Export (NSUrl url, [NullAllowed] UIImage previewImage, [NullAllowed] out NSError error);

		[Export ("referenceObjectByApplyingTransform:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		ARReferenceObject ApplyTransform (Matrix4 transform);

		[Export ("referenceObjectByMergingObject:error:")]
		[return: NullAllowed]
		ARReferenceObject Merge (ARReferenceObject @object, [NullAllowed] out NSError error);

		[iOS (12,0)]
		[Field ("ARReferenceObjectArchiveExtension")]
		NSString ArchiveExtension { get; }
	}

	[iOS (12,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(ARAnchor))]
	[DisableDefaultCtor]
	interface ARObjectAnchor {
		// Inlined from 'ARAnchorCopying' protocol (we can't have constructors in interfaces)
		[iOS (12,0)]
		[Export ("initWithAnchor:")]
		IntPtr Constructor (ARAnchor anchor);

		[Export ("referenceObject", ArgumentSemantic.Strong)]
		ARReferenceObject ReferenceObject { get; }
	}

	[iOS (12,0)]
	[NoWatch, NoTV, NoMac]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARWorldMap : NSCopying, NSSecureCoding {
		[Export ("center")]
		Vector3 Center {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("extent")]
		Vector3 Extent {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("anchors", ArgumentSemantic.Copy)]
		ARAnchor[] Anchors { get; set; }

		[Export ("rawFeaturePoints", ArgumentSemantic.Strong)]
		ARPointCloud RawFeaturePoints { get; }
	}

	[iOS (13,0)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARBody2D {

		[Export ("skeleton")]
		ARSkeleton2D Skeleton { get; }
	}

	[iOS (13,0)]
	[BaseType (typeof(ARAnchor))]
	[DisableDefaultCtor]
	interface ARBodyAnchor : ARTrackable {

		[Export ("initWithAnchor:")]
		IntPtr Constructor (ARAnchor anchor);

		// [Export ("initWithTransform:")] marked as NS_UNAVAILABLE
		// [Export ("initWithName:")] marked as NS_UNAVAILABLE

		[Export ("skeleton", ArgumentSemantic.Strong)]
		ARSkeleton3D Skeleton { get; }

		[Export ("estimatedScaleFactor")]
		nfloat EstimatedScaleFactor { get; }
	}

	[iOS (13,0)]
	[BaseType (typeof(UIView))]
	interface ARCoachingOverlayView {

		// inherited from UIView
		[DesignatedInitializer]
		[Export ("initWithFrame:")]
		IntPtr Constructor (CGRect frame);

		[Wrap ("WeakDelegate")]
		[NullAllowed]
		IARCoachingOverlayViewDelegate Delegate { get; set; }

		[NullAllowed, Export ("delegate", ArgumentSemantic.Weak)]
		NSObject WeakDelegate { get; set; }

		[NullAllowed, Export ("sessionProvider", ArgumentSemantic.Weak)]
		IARSessionProviding SessionProvider { get; set; }

		[NullAllowed, Export ("session", ArgumentSemantic.Strong)]
		ARSession Session { get; set; }

		[Export ("goal", ArgumentSemantic.Assign)]
		ARCoachingGoal Goal { get; set; }

		[Export ("activatesAutomatically")]
		bool ActivatesAutomatically { get; set; }

		[Export ("isActive")]
		bool IsActive { get; }

		[Export ("setActive:animated:")]
		void SetActive (bool active, bool animated);
	}

	interface IARCoachingOverlayViewDelegate {}

	[iOS (13,0)]
	[Protocol, Model (AutoGeneratedName = true)]
	[BaseType (typeof(NSObject))]
	interface ARCoachingOverlayViewDelegate {

		[Export ("coachingOverlayViewDidRequestSessionReset:")]
		void DidRequestSessionReset (ARCoachingOverlayView coachingOverlayView);

		[Export ("coachingOverlayViewWillActivate:")]
		void WillActivate (ARCoachingOverlayView coachingOverlayView);

		[Export ("coachingOverlayViewDidDeactivate:")]
		void DidDeactivate (ARCoachingOverlayView coachingOverlayView);
	}

	[iOS (13,0)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARCollaborationData : NSSecureCoding {

		[Export ("priority")]
		ARCollaborationDataPriority Priority { get; }
	}

	[iOS (13,0)]
	[BaseType (typeof(ARConfiguration))]
	interface ARBodyTrackingConfiguration {

		// From the parent, needed in all subclasses
		[Static]
		[Export ("supportedVideoFormats")]
		ARVideoFormat[] GetSupportedVideoFormats ();

		[Export ("autoFocusEnabled")]
		bool AutoFocusEnabled { [Bind ("isAutoFocusEnabled")] get; set; }

		[NullAllowed, Export ("initialWorldMap", ArgumentSemantic.Strong)]
		ARWorldMap InitialWorldMap { get; set; }

		[Export ("environmentTexturing", ArgumentSemantic.Assign)]
		AREnvironmentTexturing EnvironmentTexturing { get; set; }

		[Export ("wantsHDREnvironmentTextures")]
		bool WantsHdrEnvironmentTextures { get; set; }

		[Export ("planeDetection", ArgumentSemantic.Assign)]
		ARPlaneDetection PlaneDetection { get; set; }

		[Export ("detectionImages", ArgumentSemantic.Copy)]
		NSSet<ARReferenceImage> DetectionImages { get; set; }

		[Export ("automaticImageScaleEstimationEnabled")]
		bool AutomaticImageScaleEstimationEnabled { get; set; }

		[Export ("automaticSkeletonScaleEstimationEnabled")]
		bool AutomaticSkeletonScaleEstimationEnabled { get; set; }

		[Export ("maximumNumberOfTrackedImages")]
		nint MaximumNumberOfTrackedImages { get; set; }

		[Static]
		[Export ("supportsFrameSemantics:")]
		bool SupportsFrameSemantics (ARFrameSemantics frameSemantics);
	}

	[iOS (13,0)]
	[BaseType (typeof(ARConfiguration))]
	interface ARPositionalTrackingConfiguration {

		// From the parent, needed in all subclasses
		[Static]
		[Export ("supportedVideoFormats")]
		ARVideoFormat[] GetSupportedVideoFormats ();

		[Export ("planeDetection", ArgumentSemantic.Assign)]
		ARPlaneDetection PlaneDetection { get; set; }

		[NullAllowed, Export ("initialWorldMap", ArgumentSemantic.Strong)]
		ARWorldMap InitialWorldMap { get; set; }

		[Static]
		[Export ("supportsFrameSemantics:")]
		bool SupportsFrameSemantics (ARFrameSemantics frameSemantics);
	}

	[iOS (13,0)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARMatteGenerator {

		[DesignatedInitializer]
		[Export ("initWithDevice:matteResolution:")]
		IntPtr Constructor (IMTLDevice device, ARMatteResolution matteResolution);

		[Export ("generateMatteFromFrame:commandBuffer:")]
		IMTLTexture GenerateMatte (ARFrame frame, IMTLCommandBuffer commandBuffer);

		[Export ("generateDilatedDepthFromFrame:commandBuffer:")]
		IMTLTexture GenerateDilatedDepth (ARFrame frame, IMTLCommandBuffer commandBuffer);
	}

	[iOS (13,0)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARQuickLookPreviewItem : QLPreviewItem {

		[Export ("initWithFileAtURL:")]
		[DesignatedInitializer]
		IntPtr Constructor (NSUrl url);

		[NullAllowed, Export ("canonicalWebPageURL", ArgumentSemantic.Strong)]
		NSUrl CanonicalWebPageUrl { get; set; }

		[Export ("allowsContentScaling")]
		bool AllowsContentScaling { get; set; }
	}

	[iOS (13,0)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARRaycastQuery {

		[Export ("initWithOrigin:direction:allowingTarget:alignment:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		IntPtr Constructor (Vector3 origin, Vector3 direction, ARRaycastTarget target, ARRaycastTargetAlignment alignment);

		[Export ("origin")]
		Vector3 Origin {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("direction")]
		Vector3 Direction {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("target")]
		ARRaycastTarget Target { get; }

		[Export ("targetAlignment")]
		ARRaycastTargetAlignment TargetAlignment { get; }
	}

	[iOS (13,0)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARRaycastResult {

		[Export ("worldTransform")]
		Matrix4 WorldTransform {
			[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
			get;
		}

		[Export ("target", ArgumentSemantic.Assign)]
		ARRaycastTarget Target { get; }

		[Export ("targetAlignment", ArgumentSemantic.Assign)]
		ARRaycastTargetAlignment TargetAlignment { get; }

		[NullAllowed, Export ("anchor", ArgumentSemantic.Strong)]
		ARAnchor Anchor { get; }
	}

	interface IARSessionProviding {}

	[iOS (13,0)]
	[Protocol]
	interface ARSessionProviding {

		[Abstract]
		[Export ("session")]
		ARSession Session { get; }
	}

	[iOS (13,0)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARSkeleton {

		[Export ("definition")]
		ARSkeletonDefinition Definition { get; }

		[Export ("jointCount")]
		nuint JointCount { get; }

		[Export ("isJointTracked:")]
		bool IsJointTracked (nint jointIndex);
	}

	[iOS (13,0)]
	[BaseType (typeof(ARSkeleton))]
	[DisableDefaultCtor]
	interface ARSkeleton3D {

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Protected, Export ("jointModelTransforms")]
		IntPtr RawJointModelTransforms { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Protected, Export ("jointLocalTransforms")]
		IntPtr RawJointLocalTransforms { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("modelTransformForJointName:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		Matrix4 GetModelTransform (NSString jointName);

		[Wrap ("GetModelTransform (jointName.GetConstant()!)")]
		Matrix4 GetModelTransform (ARSkeletonJointName jointName);

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("localTransformForJointName:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		Matrix4 GetLocalTransform (NSString jointName);

		[Wrap ("GetLocalTransform (jointName.GetConstant()!)")]
		Matrix4 GetLocalTransform (ARSkeletonJointName jointName);
	}

	[iOS (13,0)]
	[BaseType (typeof(ARSkeleton))]
	[DisableDefaultCtor]
	interface ARSkeleton2D {

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Protected, Export ("jointLandmarks")]
		IntPtr RawJointLandmarks { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("landmarkForJointNamed:")]
		[MarshalDirective (NativePrefix = "xamarin_simd__", Library = "__Internal")]
		Vector2 GetLandmarkPoint (NSString jointName);

		[Wrap ("GetLandmarkPoint (jointName.GetConstant()!)")]
		Vector2 GetLandmarkPoint (ARSkeletonJointName jointName);
	}

	[iOS (13,0)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARSkeletonDefinition {

		[Static]
		[Export ("defaultBody3DSkeletonDefinition")]
		ARSkeletonDefinition DefaultBody3DSkeletonDefinition { get; }

		[Static]
		[Export ("defaultBody2DSkeletonDefinition")]
		ARSkeletonDefinition DefaultBody2DSkeletonDefinition { get; }

		[Export ("jointCount")]
		nuint JointCount { get; }

		[Export ("jointNames")]
		string[] JointNames { get; }

		[Export ("parentIndices")]
		NSNumber[] ParentIndices { get; }

		[NullAllowed, Export ("neutralBodySkeleton3D")]
		ARSkeleton3D NeutralBodySkeleton3D { get; }

		[EditorBrowsable (EditorBrowsableState.Advanced)]
		[Export ("indexForJointName:")]
		nuint GetJointIndex (NSString? jointName);

		[Wrap ("GetJointIndex (jointName.GetConstant()!)")]
		nuint GetJointIndex (ARSkeletonJointName jointName);
	}

	[iOS (13,0)]
	enum ARSkeletonJointName {

		[Field ("ARSkeletonJointNameRoot")]
		Root,

		[Field ("ARSkeletonJointNameHead")]
		Head,

		[Field ("ARSkeletonJointNameLeftHand")]
		LeftHand,

		[Field ("ARSkeletonJointNameRightHand")]
		RightHand,

		[Field ("ARSkeletonJointNameLeftFoot")]
		LeftFoot,

		[Field ("ARSkeletonJointNameRightFoot")]
		RightFoot,

		[Field ("ARSkeletonJointNameLeftShoulder")]
		LeftShoulder,

		[Field ("ARSkeletonJointNameRightShoulder")]
		RightShoulder,
	}

	[iOS (13,0)]
	[BaseType (typeof(NSObject))]
	[DisableDefaultCtor]
	interface ARTrackedRaycast {

		[Export ("stopTracking")]
		void StopTracking ();
	}

	[iOS (13,0)]
	[BaseType (typeof (ARAnchor))]
	[DisableDefaultCtor]
	interface ARParticipantAnchor {

		// Inlined from 'ARAnchorCopying' protocol (we can't have constructors in interfaces)
		[Export ("initWithAnchor:")]
		IntPtr Constructor (ARAnchor anchor);

		// [Export ("initWithTransform:")] marked as NS_UNAVAILABLE
		// [Export ("initWithName:")] marked as NS_UNAVAILABLE
	}

	[iOS (13,4)]
	[Native]
	[Flags]
	enum ARSceneReconstruction : ulong {
		None = 0,
		Mesh = 1,
		MeshWithClassification = (1 << 1) | (1 << 0),
	}

	[iOS (13,4)]
	[BaseType (typeof (ARAnchor))]
	[DisableDefaultCtor]
	interface ARMeshAnchor {

		// Inlined from 'ARAnchorCopying' protocol (we can't have constructors in interfaces)
		[Export ("initWithAnchor:")]
		IntPtr Constructor (ARAnchor anchor);

		// [Export ("initWithTransform:")] marked as NS_UNAVAILABLE
		// [Export ("initWithName:")] marked as NS_UNAVAILABLE

		[Export ("geometry")]
		ARMeshGeometry Geometry { get; }
	}

	[iOS (13,4)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface ARGeometrySource : NSSecureCoding {

		[Export ("buffer", ArgumentSemantic.Strong)]
		IMTLBuffer Buffer { get; }

		[Export ("count")]
		nint Count { get; }

		[Export ("format", ArgumentSemantic.Assign)]
		MTLVertexFormat Format { get; }

		[Export ("componentsPerVector")]
		nint ComponentsPerVector { get; }

		[Export ("offset")]
		nint Offset { get; }

		[Export ("stride")]
		nint Stride { get; }
	}

	[iOS (13,4)]
	[Native]
	enum ARGeometryPrimitiveType : long {
		Line,
		Triangle,
	}

	[iOS (13,4)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface ARGeometryElement : NSSecureCoding {

		[Export ("buffer", ArgumentSemantic.Strong)]
		IMTLBuffer Buffer { get; }

		[Export ("count")]
		nint Count { get; }

		[Export ("bytesPerIndex")]
		nint BytesPerIndex { get; }

		[Export ("indexCountPerPrimitive")]
		nint IndexCountPerPrimitive { get; }

		[Export ("primitiveType", ArgumentSemantic.Assign)]
		ARGeometryPrimitiveType PrimitiveType { get; }
	}

	[iOS (13,4)]
	[Native]
	enum ARMeshClassification : long {
		None,
		Wall,
		Floor,
		Ceiling,
		Table,
		Seat,
		Window,
		Door,
	}

	[iOS (13,4)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface ARMeshGeometry : NSSecureCoding {

		[Export ("vertices", ArgumentSemantic.Strong)]
		ARGeometrySource Vertices { get; }

		[Export ("normals", ArgumentSemantic.Strong)]
		ARGeometrySource Normals { get; }

		[Export ("faces", ArgumentSemantic.Strong)]
		ARGeometryElement Faces { get; }

		[Export ("classification", ArgumentSemantic.Strong)]
		[NullAllowed]
		ARGeometrySource Classification { get; }
	}

	[iOS (14, 0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface ARDepthData {
		[Export ("depthMap", ArgumentSemantic.Assign)]
		CVPixelBuffer DepthMap { get; }

		[NullAllowed, Export ("confidenceMap", ArgumentSemantic.Assign)]
		CVPixelBuffer ConfidenceMap { get; }
	}

	[iOS (14, 0)]
	[BaseType (typeof (ARAnchor))]
	interface ARGeoAnchor : ARTrackable {
		// Inlined from 'ARAnchorCopying' protocol (we can't have constructors in interfaces)
		[iOS (14,0)]
		[Export ("initWithAnchor:")]
		IntPtr Constructor (ARAnchor anchor);

		[Export ("coordinate")]
		CLLocationCoordinate2D Coordinate { get; }

		[Export ("altitude")]
		double Altitude { get; }

		[Export ("altitudeSource", ArgumentSemantic.Assign)]
		ARAltitudeSource AltitudeSource { get; }

		[Export ("initWithCoordinate:")]
		IntPtr Constructor (CLLocationCoordinate2D coordinate);

		[Export ("initWithCoordinate:altitude:")]
		IntPtr Constructor (CLLocationCoordinate2D coordinate, double altitude);

		[Export ("initWithName:coordinate:")]
		IntPtr Constructor (string name, CLLocationCoordinate2D coordinate);

		[Export ("initWithName:coordinate:altitude:")]
		IntPtr Constructor (string name, CLLocationCoordinate2D coordinate, double altitude);
	}

	[iOS (14, 0)]
	[BaseType (typeof (ARConfiguration))]
	interface ARGeoTrackingConfiguration {
		[Static]
		[Export ("supportedVideoFormats")]
		ARVideoFormat[] GetSupportedVideoFormats ();

		[Export ("environmentTexturing", ArgumentSemantic.Assign)]
		AREnvironmentTexturing EnvironmentTexturing { get; set; }

		[Export ("wantsHDREnvironmentTextures")]
		bool WantsHdrEnvironmentTextures { get; set; }

		[Export ("planeDetection", ArgumentSemantic.Assign)]
		ARPlaneDetection PlaneDetection { get; set; }

		[NullAllowed, Export ("detectionImages", ArgumentSemantic.Copy)]
		NSSet<ARReferenceImage> DetectionImages { get; set; }

		[Export ("automaticImageScaleEstimationEnabled")]
		bool AutomaticImageScaleEstimationEnabled { get; set; }

		[Export ("maximumNumberOfTrackedImages")]
		nint MaximumNumberOfTrackedImages { get; set; }

		[Export ("detectionObjects", ArgumentSemantic.Copy)]
		NSSet<ARReferenceObject> DetectionObjects { get; set; }

		[Async]
		[Static]
		[Export ("checkAvailabilityWithCompletionHandler:")]
		void CheckAvailability (Action<bool, NSError> completionHandler);

		[Async]
		[Static]
		[Export ("checkAvailabilityAtCoordinate:completionHandler:")]
		void CheckAvailability (CLLocationCoordinate2D coordinate, Action<bool, NSError> completionHandler);

		[Static]
		[Export ("new")]
		[return: Release]
		ARGeoTrackingConfiguration Create ();

		[Static]
		[Export ("supportsFrameSemantics:")]
		bool SupportsFrameSemantics (ARFrameSemantics frameSemantics);
	}

	[iOS (14, 0)]
	[BaseType (typeof (NSObject))]
	[DisableDefaultCtor]
	interface ARGeoTrackingStatus : NSCopying, NSSecureCoding {
		[Export ("state")]
		ARGeoTrackingState State { get; }

		[Export ("accuracy")]
		ARGeoTrackingAccuracy Accuracy { get; }

		[Export ("stateReason")]
		ARGeoTrackingStateReason StateReason { get; }
	}

}