objc2_sensor_kit/generated/

mod.rs

// This file has been automatically generated by `objc2`'s `header-translator`.
// DO NOT EDIT

#![allow(unused_imports)]
#![allow(deprecated)]
#![allow(non_snake_case)]
#![allow(non_camel_case_types)]
#![allow(non_upper_case_globals)]
#![allow(missing_docs)]
#![allow(clippy::too_many_arguments)]
#![allow(clippy::type_complexity)]
#![allow(clippy::upper_case_acronyms)]
#![allow(clippy::identity_op)]
#![allow(clippy::missing_safety_doc)]
#![allow(clippy::doc_lazy_continuation)]
#![allow(rustdoc::broken_intra_doc_links)]
#![allow(rustdoc::bare_urls)]
#![allow(rustdoc::unportable_markdown)]
#![allow(rustdoc::invalid_html_tags)]

#[link(name = "SensorKit", kind = "framework")]
extern "C" {}

use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
#[cfg(feature = "objc2-ar-kit")]
use objc2_ar_kit::*;
#[cfg(feature = "objc2-core-foundation")]
use objc2_core_foundation::*;
#[cfg(feature = "objc2-core-location")]
use objc2_core_location::*;
#[cfg(feature = "objc2-core-media")]
use objc2_core_media::*;
use objc2_foundation::*;
#[cfg(feature = "objc2-sound-analysis")]
use objc2_sound_analysis::*;
#[cfg(feature = "objc2-speech")]
use objc2_speech::*;

use crate::*;

/// A type of data stream stored in the SensorKit data store.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensor?language=objc)
// NS_TYPED_ENUM
pub type SRSensor = NSString;

extern "C" {
    /// Sensor stream for Environmental Brightness and Color.
    ///
    ///
    /// This data stream stores ambient light sensor data from devices when the screen is on.
    /// Fetches from this stream return objects of type SRAmbientLightSample.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorambientlightsensor?language=objc)
    pub static SRSensorAmbientLightSensor: &'static SRSensor;
}

extern "C" {
    /// Accelerometer sensor stream for Motion.
    ///
    ///
    /// This data stream stores acceleration measured by the device's accelerometer.
    /// Fetches from this stream return objects of type NSArray
    /// <CMRecordedAccelerometerData
    /// *> * as defined in the CoreMotion framework.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensoraccelerometer?language=objc)
    pub static SRSensorAccelerometer: &'static SRSensor;
}

extern "C" {
    /// Rotation rate sensor stream for Motion.
    ///
    ///
    /// This data stream stores rotation rate measured by the device's gyroscope.
    /// Fetches from this stream return objects of type NSArray
    /// <CMRecordedRotationRateData
    /// *> * as defined in the CoreMotion framework.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorrotationrate?language=objc)
    pub static SRSensorRotationRate: &'static SRSensor;
}

extern "C" {
    /// Sensor stream for Frequently Visited Locations.
    ///
    ///
    /// This data stream stores visit information from frequently visited locations including:
    ///
    /// ```text
    ///    - arrival and departure times
    ///    - distance from your home
    ///    - an anonymous location identifier but no specific location information
    /// ```
    ///
    /// Fetches from this stream return objects of type SRVisit.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorvisits?language=objc)
    pub static SRSensorVisits: &'static SRSensor;
}

extern "C" {
    /// Sensor stream for Pedometer.
    ///
    ///
    /// This stream stores information about your step count.
    /// Fetches from this stream return objects of type CMPedometerData as defined in the CoreMotion framework.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorpedometerdata?language=objc)
    pub static SRSensorPedometerData: &'static SRSensor;
}

extern "C" {
    /// Sensor stream for Device Usage.
    ///
    ///
    /// This stream stores information about device usage including:
    ///
    /// ```text
    ///    - Types of apps used
    ///    - Types of notifications received
    ///    - Types of websites visited
    ///    - Number of device unlocks and unlock duration
    ///    - Number of times the screen is on and the duration
    /// ```
    ///
    /// Fetches from this stream return objects of type SRDeviceUsageReport.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensordeviceusagereport?language=objc)
    pub static SRSensorDeviceUsageReport: &'static SRSensor;
}

extern "C" {
    /// Sensor stream for Messages Usage.
    ///
    ///
    /// This streams stores information about messages usage including:
    ///
    /// ```text
    ///    - The number of incoming and outgoing messages
    ///    - The number of individuals contacted but none of their personal information
    /// ```
    ///
    /// Fetches from this stream return objects of type SRMessagesUsageReport.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensormessagesusagereport?language=objc)
    pub static SRSensorMessagesUsageReport: &'static SRSensor;
}

extern "C" {
    /// Sensor stream for Phone Usage
    ///
    ///
    /// This streams stores information about phone usage including:
    ///
    /// ```text
    ///    - The number of incoming and outgoing calls
    ///    - The number of individuals contacted but none of their personal information
    /// ```
    ///
    /// Fetches from this stream return objects of type SRPhoneUsageReport.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorphoneusagereport?language=objc)
    pub static SRSensorPhoneUsageReport: &'static SRSensor;
}

extern "C" {
    /// Sensor stream for Watch on Wrist
    ///
    ///
    /// This streams stores information about Apple Watch wear including:
    ///
    /// ```text
    ///    - When the watch is worn
    ///    - Digital crown and orientation settings
    /// ```
    ///
    /// Fetches from this stream return objects of type SRWristDetection.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensoronwriststate?language=objc)
    pub static SRSensorOnWristState: &'static SRSensor;
}

extern "C" {
    /// Sensor stream for Keyboard Usage
    ///
    ///
    /// This stream stores information about keyboard usage from all apps where a keyboard is used including:
    ///
    /// ```text
    ///    - Metrics about typing speed and accuracy
    ///    - Metrics about the length of typed or swiped words
    ///    - Metrics about the typing errors made
    ///    - The number of words and emojis that convey emotion
    /// ```
    ///
    /// Fetches from this stream return objects of type SRKeyboardMetrics.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorkeyboardmetrics?language=objc)
    pub static SRSensorKeyboardMetrics: &'static SRSensor;
}

extern "C" {
    /// Siri sensor stream for Speech Metrics
    ///
    ///
    /// This stream stores information data about your voice during Siri sessions including:
    ///
    /// ```text
    ///    - Tenor, pitch, and cadence
    ///    - Metrics such as average words per minute and average pause length
    /// ```
    ///
    /// This steam does not store any raw audio nor any audio or data from other parties.
    ///
    /// Fetches from this stream return objects of type
    /// `SRSpeechMetrics`
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorsirispeechmetrics?language=objc)
    pub static SRSensorSiriSpeechMetrics: &'static SRSensor;
}

extern "C" {
    /// Telephony sensor stream for Speech Metrics
    ///
    ///
    /// This stream stores information data about your voice during phone calls including:
    ///
    /// ```text
    ///    - Tenor, pitch, and cadence
    ///    - Metrics such as average words per minute and average pause length
    /// ```
    ///
    /// This steam does not store any raw audio nor any audio or data from other parties.
    ///
    /// Fetches from this stream return objects of type
    /// `SRSpeechMetrics`
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensortelephonyspeechmetrics?language=objc)
    pub static SRSensorTelephonySpeechMetrics: &'static SRSensor;
}

extern "C" {
    /// Ambient pressure sensor stream
    ///
    ///
    /// This stream stores simple pressure and temperature measurements including:
    ///
    /// ```text
    ///    - Pressure and temperature
    ///    - Date when metric was collected
    /// ```
    ///
    /// Fetches from this stream return objects of type NSArray
    /// <CMRecordedPressureData
    /// *> * as defined in the CoreMotion framework.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorambientpressure?language=objc)
    pub static SRSensorAmbientPressure: &'static SRSensor;
}

extern "C" {
    /// Media events sensor stream
    ///
    ///
    /// This stream stores data about user interaction with photo and video content in messaging apps including:
    ///
    /// ```text
    ///    - Event type
    ///    - Media identifier
    /// ```
    ///
    /// Fetches from this stream return objects of type SRMediaEvent.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensormediaevents?language=objc)
    pub static SRSensorMediaEvents: &'static SRSensor;
}

extern "C" {
    /// Sensor stream for Apple Watch temperatures on wrist while sleeping
    ///
    ///
    /// This stream stores Apple Watch on wrist temperature measurements including:
    ///
    /// ```text
    ///    - StartTime
    ///    - Duration of collected temperature measurements
    ///    - version of algorithm
    ///    - Temperature samples
    /// ```
    ///
    /// Fetches from this stream return objects of type SRWristTemperatureSession.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorwristtemperature?language=objc)
    pub static SRSensorWristTemperature: &'static SRSensor;
}

extern "C" {
    /// Estimated heart rate
    ///
    ///
    /// Fetches from this stream return objects of type
    /// `CMHighFrequencyHeartRateData`
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorheartrate?language=objc)
    pub static SRSensorHeartRate: &'static SRSensor;
}

extern "C" {
    /// Sensor stream for face metrics collection
    ///
    ///
    /// This stream stores face metrics including:
    ///
    /// ```text
    ///    - algorithm version
    ///    - face description and face expressions
    ///    - data collection session identifier
    /// ```
    ///
    /// Fetches from this stream return objects of type SRFaceMetrics.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorfacemetrics?language=objc)
    pub static SRSensorFaceMetrics: &'static SRSensor;
}

extern "C" {
    /// Odometer sensor stream
    ///
    ///
    /// This stream stores measurements of your distance and speed
    /// Fetches from this stream return objects of type
    /// `CMOdometerData`as defined in the CoreMotion framework.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorodometer?language=objc)
    pub static SRSensorOdometer: &'static SRSensor;
}

extern "C" {
    /// ECG sensor stream
    ///
    ///
    /// This stream stores samples of the ECG sensor
    /// Fetches from this stream return objects of type
    /// `NSArray<SRElectrocardiogramSample`*> *
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorelectrocardiogram?language=objc)
    pub static SRSensorElectrocardiogram: &'static SRSensor;
}

extern "C" {
    /// PPG sensor stream
    ///
    ///
    /// This stream stores samples of the PPG sensor
    /// Fetches from this stream return objects of type
    /// `NSArray<SRPhotoplethysmogramSample`*> *
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorphotoplethysmogram?language=objc)
    pub static SRSensorPhotoplethysmogram: &'static SRSensor;
}

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srabsolutetime?language=objc)
#[cfg(feature = "objc2-core-foundation")]
pub type SRAbsoluteTime = CFTimeInterval;

extern "C-unwind" {
    /// Get the current SRAbsoluteTime for this device.
    ///
    /// This timestamp ticks across sleeps and reboots.
    #[cfg(feature = "objc2-core-foundation")]
    pub fn SRAbsoluteTimeGetCurrent() -> SRAbsoluteTime;
}

extern "C-unwind" {
    /// Convert a mach_continuous_time to an SRAbsoluteTime.
    ///
    /// Because mach_continuous_time is volatile and hardware specific, the
    /// mach_continuous_time must originate from the same device and boot session
    /// that SRAbsoluteTimeFromContinuousTime() is called from.
    /// The return value for mach_continuous_times spanning boot sessions or devices
    /// is undefined.
    #[cfg(feature = "objc2-core-foundation")]
    pub fn SRAbsoluteTimeFromContinuousTime(cont: u64) -> SRAbsoluteTime;
}

extern "C-unwind" {
    /// Convert a SRAbsoluteTime to a CFAbsoluteTime.
    ///
    /// The CFAbsoluteTime returned is based on calculations relative to the current
    /// wall clock. This means that if the system time is 5 seconds fast against UTC,
    /// the result will be 5 seconds fast to when the event happened relative to UTC.
    #[cfg(feature = "objc2-core-foundation")]
    pub fn SRAbsoluteTimeToCFAbsoluteTime(sr: SRAbsoluteTime) -> CFAbsoluteTime;
}

extern "C-unwind" {
    /// Convert a CFAbsoluteTime to an SRAbsoluteTime.
    ///
    /// The SRAbsoluteTime returned is based on calculations relative to the current
    /// wall clock. This means that if the system time is 5 seconds fast against UTC,
    /// the result will be 5 seconds fast to when the event happened relative to UTC.
    #[cfg(feature = "objc2-core-foundation")]
    pub fn SRAbsoluteTimeFromCFAbsoluteTime(cf: CFAbsoluteTime) -> SRAbsoluteTime;
}

mod private_NSDateSensorKit {
    pub trait Sealed {}
}

/// Category "SensorKit" on [`NSDate`].
#[doc(alias = "SensorKit")]
pub unsafe trait NSDateSensorKit:
    ClassType + Sized + private_NSDateSensorKit::Sealed
{
    extern_methods!(
        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(dateWithSRAbsoluteTime:))]
        #[unsafe(method_family = none)]
        unsafe fn dateWithSRAbsoluteTime(time: SRAbsoluteTime) -> Retained<Self>;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(initWithSRAbsoluteTime:))]
        #[unsafe(method_family = init)]
        unsafe fn initWithSRAbsoluteTime(
            this: Allocated<Self>,
            time: SRAbsoluteTime,
        ) -> Retained<Self>;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(srAbsoluteTime))]
        #[unsafe(method_family = none)]
        unsafe fn srAbsoluteTime(&self) -> SRAbsoluteTime;
    );
}

impl private_NSDateSensorKit::Sealed for NSDate {}
unsafe impl NSDateSensorKit for NSDate {}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srfetchresult?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRFetchResult<SampleType: ?Sized = AnyObject>;
);

extern_conformance!(
    unsafe impl<SampleType: ?Sized> NSCopying for SRFetchResult<SampleType> {}
);

unsafe impl<SampleType: ?Sized + Message> CopyingHelper for SRFetchResult<SampleType> {
    type Result = Self;
}

extern_conformance!(
    unsafe impl<SampleType: ?Sized> NSObjectProtocol for SRFetchResult<SampleType> {}
);

impl<SampleType: Message> SRFetchResult<SampleType> {
    extern_methods!(
        /// Retrieves the resultant sample
        ///
        /// The caller is expected to know what the result type should be
        ///
        /// Note: This may thrown an exception if the sample could not be constructed from
        /// the data in the datastore
        #[unsafe(method(sample))]
        #[unsafe(method_family = none)]
        pub unsafe fn sample(&self) -> Retained<SampleType>;

        #[cfg(feature = "objc2-core-foundation")]
        /// the timestamp the sample was written to the data store
        #[unsafe(method(timestamp))]
        #[unsafe(method_family = none)]
        pub unsafe fn timestamp(&self) -> SRAbsoluteTime;

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdevice?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRDevice;
);

extern_conformance!(
    unsafe impl NSCoding for SRDevice {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRDevice {}
);

impl SRDevice {
    extern_methods!(
        #[unsafe(method(currentDevice))]
        #[unsafe(method_family = none)]
        pub unsafe fn currentDevice() -> Retained<SRDevice>;

        #[unsafe(method(name))]
        #[unsafe(method_family = none)]
        pub unsafe fn name(&self) -> Retained<NSString>;

        #[unsafe(method(model))]
        #[unsafe(method_family = none)]
        pub unsafe fn model(&self) -> Retained<NSString>;

        #[unsafe(method(systemName))]
        #[unsafe(method_family = none)]
        pub unsafe fn systemName(&self) -> Retained<NSString>;

        #[unsafe(method(systemVersion))]
        #[unsafe(method_family = none)]
        pub unsafe fn systemVersion(&self) -> Retained<NSString>;

        #[unsafe(method(productType))]
        #[unsafe(method_family = none)]
        pub unsafe fn productType(&self) -> Retained<NSString>;
    );
}

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

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srfetchrequest?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRFetchRequest;
);

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

impl SRFetchRequest {
    extern_methods!(
        #[cfg(feature = "objc2-core-foundation")]
        /// Fetch data starting after this time.
        ///
        /// This value must be specified for a valid request to be performed.
        /// If it is not specified, this will result in a SRErrorInvalidRequest error in the
        /// -sensorReader:fetchingRequest:failedWithError: SRSensorReaderDelegate callback.
        ///
        /// The time range for fetching will be exclusive of start time and inclusive of end time:
        /// (start, end] . An SRSensorReader can use this to continue fetching a stream of
        /// data based on the last sample timestamp they have read.
        #[unsafe(method(from))]
        #[unsafe(method_family = none)]
        pub unsafe fn from(&self) -> SRAbsoluteTime;

        #[cfg(feature = "objc2-core-foundation")]
        /// Setter for [`from`][Self::from].
        #[unsafe(method(setFrom:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setFrom(&self, from: SRAbsoluteTime);

        #[cfg(feature = "objc2-core-foundation")]
        /// Fetch data ending at this time.
        ///
        /// This value must be specified for a valid request to be performed.
        /// If it is not specified, this will result in a SRErrorInvalidRequest error in the
        /// -sensorReader:fetchingRequest:failedWithError: SRSensorReaderDelegate callback.
        #[unsafe(method(to))]
        #[unsafe(method_family = none)]
        pub unsafe fn to(&self) -> SRAbsoluteTime;

        #[cfg(feature = "objc2-core-foundation")]
        /// Setter for [`to`][Self::to].
        #[unsafe(method(setTo:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setTo(&self, to: SRAbsoluteTime);

        /// Fetch data generated on this device
        ///
        /// If this is not specified, the current device will be used.
        #[unsafe(method(device))]
        #[unsafe(method_family = none)]
        pub unsafe fn device(&self) -> Retained<SRDevice>;

        /// Setter for [`device`][Self::device].
        #[unsafe(method(setDevice:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDevice(&self, device: &SRDevice);
    );
}

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

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

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srauthorizationstatus?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRAuthorizationStatus(pub NSInteger);
impl SRAuthorizationStatus {
    /// User has not yet made a choice regarding this application
    #[doc(alias = "SRAuthorizationStatusNotDetermined")]
    pub const NotDetermined: Self = Self(0);
    /// User has granted authorization to this application
    #[doc(alias = "SRAuthorizationStatusAuthorized")]
    pub const Authorized: Self = Self(1);
    /// User has denied authorization to this application or
    /// data collection is disabled in Settings.
    #[doc(alias = "SRAuthorizationStatusDenied")]
    pub const Denied: Self = Self(2);
}

unsafe impl Encode for SRAuthorizationStatus {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

extern_protocol!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorreaderdelegate?language=objc)
    pub unsafe trait SRSensorReaderDelegate: NSObjectProtocol {
        /// Invoked when a sample has been fetched
        ///
        /// This callback can be called multiple times
        /// when there are multiple results.
        ///
        ///
        /// Parameter `fetchRequest`: The request corresponding to the this result
        ///
        /// Parameter `result`: One result of the fetch. The caller is expected to
        /// know what type of sample is returned.
        ///
        ///
        /// Note: The fetchResult is not valid after the callback is complete. If the caller needs
        /// to access the result at a later time, it must be copied not merely retained
        ///
        ///
        /// Returns: The delegate should return YES if the fetch should continue, NO if the fetch should stop
        #[optional]
        #[unsafe(method(sensorReader:fetchingRequest:didFetchResult:))]
        #[unsafe(method_family = none)]
        unsafe fn sensorReader_fetchingRequest_didFetchResult(
            &self,
            reader: &SRSensorReader,
            fetch_request: &SRFetchRequest,
            result: &SRFetchResult,
        ) -> bool;

        /// Invoked when a fetch has been completed successfully
        #[optional]
        #[unsafe(method(sensorReader:didCompleteFetch:))]
        #[unsafe(method_family = none)]
        unsafe fn sensorReader_didCompleteFetch(
            &self,
            reader: &SRSensorReader,
            fetch_request: &SRFetchRequest,
        );

        /// Invoked when a fetch has completed with an error
        #[optional]
        #[unsafe(method(sensorReader:fetchingRequest:failedWithError:))]
        #[unsafe(method_family = none)]
        unsafe fn sensorReader_fetchingRequest_failedWithError(
            &self,
            reader: &SRSensorReader,
            fetch_request: &SRFetchRequest,
            error: &NSError,
        );

        /// Invoked when authorization status has changed
        #[optional]
        #[unsafe(method(sensorReader:didChangeAuthorizationStatus:))]
        #[unsafe(method_family = none)]
        unsafe fn sensorReader_didChangeAuthorizationStatus(
            &self,
            reader: &SRSensorReader,
            authorization_status: SRAuthorizationStatus,
        );

        /// Invoked after a SRSensorReader has request that recording be
        /// started for a sensor
        #[optional]
        #[unsafe(method(sensorReaderWillStartRecording:))]
        #[unsafe(method_family = none)]
        unsafe fn sensorReaderWillStartRecording(&self, reader: &SRSensorReader);

        /// Invoked if there was an error starting recording for a given sensor
        #[optional]
        #[unsafe(method(sensorReader:startRecordingFailedWithError:))]
        #[unsafe(method_family = none)]
        unsafe fn sensorReader_startRecordingFailedWithError(
            &self,
            reader: &SRSensorReader,
            error: &NSError,
        );

        /// Invoked after a SRSensorReader has request that recording be
        /// stopped for a sensor
        #[optional]
        #[unsafe(method(sensorReaderDidStopRecording:))]
        #[unsafe(method_family = none)]
        unsafe fn sensorReaderDidStopRecording(&self, reader: &SRSensorReader);

        /// Invoked if there was an error starting recording for a given sensor
        #[optional]
        #[unsafe(method(sensorReader:stopRecordingFailedWithError:))]
        #[unsafe(method_family = none)]
        unsafe fn sensorReader_stopRecordingFailedWithError(
            &self,
            reader: &SRSensorReader,
            error: &NSError,
        );

        #[optional]
        #[unsafe(method(sensorReader:didFetchDevices:))]
        #[unsafe(method_family = none)]
        unsafe fn sensorReader_didFetchDevices(
            &self,
            reader: &SRSensorReader,
            devices: &NSArray<SRDevice>,
        );

        #[optional]
        #[unsafe(method(sensorReader:fetchDevicesDidFailWithError:))]
        #[unsafe(method_family = none)]
        unsafe fn sensorReader_fetchDevicesDidFailWithError(
            &self,
            reader: &SRSensorReader,
            error: &NSError,
        );
    }
);

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsensorreader?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRSensorReader;
);

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

impl SRSensorReader {
    extern_methods!(
        /// Initializes an SRSensorReader that will fetch data for the current device
        /// and any companion
        #[unsafe(method(initWithSensor:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSensor(this: Allocated<Self>, sensor: &SRSensor) -> Retained<Self>;

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

        /// Starts recording for the reader's sensor
        ///
        ///
        /// The reader must be authorized for the sensor for this to succeed.
        /// This starts recording on this device and any paired devices.
        /// If other readers have already started the sensor recording this
        /// reader's interest in recording will be maintained. Other readers in
        /// other apps for the same sensor will not affect the recording status
        /// of this reader.
        ///
        /// In the case of success, completion notification will be delivered
        /// to the delegate in the sensorReaderWillStartRecording:
        /// delegate method.
        ///
        /// In the case of failure, error notification will be delivered
        /// to the delegate in the sensorReader:startRecordingFailedWithError:
        /// delegate method.
        #[unsafe(method(startRecording))]
        #[unsafe(method_family = none)]
        pub unsafe fn startRecording(&self);

        /// Stops recording for the reader's sensor
        ///
        ///
        /// The reader must be authorized for the sensor for this to succeed.
        /// This stops recording on this device and any paired devices.
        /// Sensor recording will continue until the last interested reader has
        /// stopped recording.
        ///
        /// In the case of success, completion notification will be delivered
        /// to the delegate in the sensorReaderDidStopRecording:
        /// delegate method.
        ///
        /// In the case of failure, error notification will be delivered
        /// to the delegate in the sensorReader:stopRecordingFailedWithError:
        /// delegate method.
        #[unsafe(method(stopRecording))]
        #[unsafe(method_family = none)]
        pub unsafe fn stopRecording(&self);

        /// Fetches device information for all devices that have stored data for
        /// the given sensor in SensorKit
        ///
        /// If the request completes successfully, devices will be returned to the
        /// delegate in the sensorReader:fetchedDevices: callback. If the request
        /// failed, an error will be returned to the delegate in the
        /// sensorReader:fetchDevicesFailedWithError:
        /// method
        #[unsafe(method(fetchDevices))]
        #[unsafe(method_family = none)]
        pub unsafe fn fetchDevices(&self);

        /// Fetches samples for the reader's sensor for given request parameters
        ///
        ///
        /// The reader must be authorized for the sensor for this to succeed.
        ///
        /// Samples will be delivered to the delegate through multiple calls
        /// to the sensorReader:fetchingRequest:didFetchResult: delegate method
        ///
        /// In the case of a failure, any error will be delivered to the delegate in the
        /// sensorReader:fetchingRequest:failedWithError: method.
        ///
        /// In the case of success, completion notification will be delivered
        /// to the delegate in the sensorReader:didCompleteFetch: method.
        ///
        ///
        /// Parameter `request`: The query parameters for this fetch
        #[unsafe(method(fetch:))]
        #[unsafe(method_family = none)]
        pub unsafe fn fetch(&self, request: &SRFetchRequest);

        /// The current authorization status of the calling application.
        #[unsafe(method(authorizationStatus))]
        #[unsafe(method_family = none)]
        pub unsafe fn authorizationStatus(&self) -> SRAuthorizationStatus;

        /// the sensor this reader was initialized with
        #[unsafe(method(sensor))]
        #[unsafe(method_family = none)]
        pub unsafe fn sensor(&self) -> Retained<SRSensor>;

        #[unsafe(method(delegate))]
        #[unsafe(method_family = none)]
        pub unsafe fn delegate(
            &self,
        ) -> Option<Retained<ProtocolObject<dyn SRSensorReaderDelegate>>>;

        /// This is a [weak property][objc2::topics::weak_property].
        /// Setter for [`delegate`][Self::delegate].
        #[unsafe(method(setDelegate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setDelegate(
            &self,
            delegate: Option<&ProtocolObject<dyn SRSensorReaderDelegate>>,
        );

        #[cfg(feature = "block2")]
        /// Request authorization to a given set of sensors
        ///
        ///
        /// If the SRSensorReader instance is not authorized, this
        /// method must be called before any other methods. Failure to request
        /// authorization will cause errors to be returned from the other methods.
        ///
        /// When SensorKit prepares the prompt for display, it will look at the
        /// NSSensorKitUsageDetail key in your Info.plist.  The value should be
        /// a dictionary containing usage descriptions for all of the sensors being
        /// requested.  The description key you provide to this method must
        /// correspond to an entry in that dictionary.  To retrieve a localized
        /// string, SensorKit will load your InfoPlist.strings file and try to look
        /// up a string using the description key you provided.  If that fails,
        /// SensorKit will use the content provided in your Info.plist.
        ///
        /// SensorKit may decide against showing the user a prompt.  For example,
        /// if the user has already chosen whether to grant the application access
        /// to all of the types provided.  When that happens, your completion block
        /// will be called with an appropriate  NSError.  If the user responded to
        /// the prompt, your completion block will be called with a nil error.
        /// Changes in authorization status will delivered to the delegate in the
        /// sensorReader:didChangeAuthorizationStatus: method.
        #[unsafe(method(requestAuthorizationForSensors:completion:))]
        #[unsafe(method_family = none)]
        pub unsafe fn requestAuthorizationForSensors_completion(
            sensors: &NSSet<SRSensor>,
            completion: &block2::DynBlock<dyn Fn(*mut NSError)>,
        );
    );
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srerrordomain?language=objc)
    pub static SRErrorDomain: &'static NSErrorDomain;
}

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srerrorcode?language=objc)
// NS_ERROR_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRErrorCode(pub NSInteger);
impl SRErrorCode {
    /// No valid entitlement found
    #[doc(alias = "SRErrorInvalidEntitlement")]
    pub const InvalidEntitlement: Self = Self(0);
    /// Insufficient authorization to perform the action.
    #[doc(alias = "SRErrorNoAuthorization")]
    pub const NoAuthorization: Self = Self(1);
    /// Data is not accessible at this time
    #[doc(alias = "SRErrorDataInaccessible")]
    pub const DataInaccessible: Self = Self(2);
    /// Fetch request contained invalid values
    #[doc(alias = "SRErrorFetchRequestInvalid")]
    pub const FetchRequestInvalid: Self = Self(3);
    /// Authorization request not completed
    #[doc(alias = "SRErrorPromptDeclined")]
    pub const PromptDeclined: Self = Self(4);
}

unsafe impl Encode for SRErrorCode {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srambientlightsensorplacement?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRAmbientLightSensorPlacement(pub NSInteger);
impl SRAmbientLightSensorPlacement {
    #[doc(alias = "SRAmbientLightSensorPlacementUnknown")]
    pub const Unknown: Self = Self(0);
    #[doc(alias = "SRAmbientLightSensorPlacementFrontTop")]
    pub const FrontTop: Self = Self(1);
    #[doc(alias = "SRAmbientLightSensorPlacementFrontBottom")]
    pub const FrontBottom: Self = Self(2);
    #[doc(alias = "SRAmbientLightSensorPlacementFrontRight")]
    pub const FrontRight: Self = Self(3);
    #[doc(alias = "SRAmbientLightSensorPlacementFrontLeft")]
    pub const FrontLeft: Self = Self(4);
    #[doc(alias = "SRAmbientLightSensorPlacementFrontTopRight")]
    pub const FrontTopRight: Self = Self(5);
    #[doc(alias = "SRAmbientLightSensorPlacementFrontTopLeft")]
    pub const FrontTopLeft: Self = Self(6);
    #[doc(alias = "SRAmbientLightSensorPlacementFrontBottomRight")]
    pub const FrontBottomRight: Self = Self(7);
    #[doc(alias = "SRAmbientLightSensorPlacementFrontBottomLeft")]
    pub const FrontBottomLeft: Self = Self(8);
}

unsafe impl Encode for SRAmbientLightSensorPlacement {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srambientlightchromaticity?language=objc)
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct SRAmbientLightChromaticity {
    pub x: f32,
    pub y: f32,
}

unsafe impl Encode for SRAmbientLightChromaticity {
    const ENCODING: Encoding = Encoding::Struct("?", &[<f32>::ENCODING, <f32>::ENCODING]);
}

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srambientlightsample?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRAmbientLightSample;
);

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

impl SRAmbientLightSample {
    extern_methods!(
        #[unsafe(method(placement))]
        #[unsafe(method_family = none)]
        pub unsafe fn placement(&self) -> SRAmbientLightSensorPlacement;

        /// Chromaticity is only valid on supporting devices. If not supported,
        /// the values will be zero.
        #[unsafe(method(chromaticity))]
        #[unsafe(method_family = none)]
        pub unsafe fn chromaticity(&self) -> SRAmbientLightChromaticity;

        #[unsafe(method(lux))]
        #[unsafe(method_family = none)]
        pub unsafe fn lux(&self) -> Retained<NSMeasurement<NSUnitIlluminance>>;
    );
}

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

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

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srlocationcategory?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRLocationCategory(pub NSInteger);
impl SRLocationCategory {
    #[doc(alias = "SRLocationCategoryUnknown")]
    pub const Unknown: Self = Self(0);
    #[doc(alias = "SRLocationCategoryHome")]
    pub const Home: Self = Self(1);
    #[doc(alias = "SRLocationCategoryWork")]
    pub const Work: Self = Self(2);
    #[doc(alias = "SRLocationCategorySchool")]
    pub const School: Self = Self(3);
    #[doc(alias = "SRLocationCategoryGym")]
    pub const Gym: Self = Self(4);
}

unsafe impl Encode for SRLocationCategory {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srvisit?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRVisit;
);

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

impl SRVisit {
    extern_methods!(
        #[cfg(feature = "objc2-core-location")]
        /// The distance between the location of interest to home
        #[unsafe(method(distanceFromHome))]
        #[unsafe(method_family = none)]
        pub unsafe fn distanceFromHome(&self) -> CLLocationDistance;

        /// The range of time the arrival to a location of interest occurred
        #[unsafe(method(arrivalDateInterval))]
        #[unsafe(method_family = none)]
        pub unsafe fn arrivalDateInterval(&self) -> Retained<NSDateInterval>;

        /// The range of time the departure from a location of interest occurred
        #[unsafe(method(departureDateInterval))]
        #[unsafe(method_family = none)]
        pub unsafe fn departureDateInterval(&self) -> Retained<NSDateInterval>;

        #[unsafe(method(locationCategory))]
        #[unsafe(method_family = none)]
        pub unsafe fn locationCategory(&self) -> SRLocationCategory;

        /// An identifier for the location of interest.
        /// This can be used to identify the same location regardless of type
        #[unsafe(method(identifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn identifier(&self) -> Retained<NSUUID>;
    );
}

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

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

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorykey?language=objc)
// NS_TYPED_ENUM
pub type SRDeviceUsageCategoryKey = NSString;

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorygames?language=objc)
    pub static SRDeviceUsageCategoryGames: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorybusiness?language=objc)
    pub static SRDeviceUsageCategoryBusiness: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategoryweather?language=objc)
    pub static SRDeviceUsageCategoryWeather: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategoryutilities?language=objc)
    pub static SRDeviceUsageCategoryUtilities: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorytravel?language=objc)
    pub static SRDeviceUsageCategoryTravel: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorysports?language=objc)
    pub static SRDeviceUsageCategorySports: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorysocialnetworking?language=objc)
    pub static SRDeviceUsageCategorySocialNetworking: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategoryreference?language=objc)
    pub static SRDeviceUsageCategoryReference: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategoryproductivity?language=objc)
    pub static SRDeviceUsageCategoryProductivity: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategoryphotoandvideo?language=objc)
    pub static SRDeviceUsageCategoryPhotoAndVideo: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorynews?language=objc)
    pub static SRDeviceUsageCategoryNews: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorynavigation?language=objc)
    pub static SRDeviceUsageCategoryNavigation: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorymusic?language=objc)
    pub static SRDeviceUsageCategoryMusic: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorylifestyle?language=objc)
    pub static SRDeviceUsageCategoryLifestyle: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategoryhealthandfitness?language=objc)
    pub static SRDeviceUsageCategoryHealthAndFitness: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategoryfinance?language=objc)
    pub static SRDeviceUsageCategoryFinance: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategoryentertainment?language=objc)
    pub static SRDeviceUsageCategoryEntertainment: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategoryeducation?language=objc)
    pub static SRDeviceUsageCategoryEducation: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorybooks?language=objc)
    pub static SRDeviceUsageCategoryBooks: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorymedical?language=objc)
    pub static SRDeviceUsageCategoryMedical: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorynewsstand?language=objc)
    pub static SRDeviceUsageCategoryNewsstand: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorycatalogs?language=objc)
    pub static SRDeviceUsageCategoryCatalogs: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorykids?language=objc)
    pub static SRDeviceUsageCategoryKids: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorymiscellaneous?language=objc)
    pub static SRDeviceUsageCategoryMiscellaneous: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategoryfoodanddrink?language=objc)
    pub static SRDeviceUsageCategoryFoodAndDrink: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorydevelopertools?language=objc)
    pub static SRDeviceUsageCategoryDeveloperTools: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorygraphicsanddesign?language=objc)
    pub static SRDeviceUsageCategoryGraphicsAndDesign: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategoryshopping?language=objc)
    pub static SRDeviceUsageCategoryShopping: &'static SRDeviceUsageCategoryKey;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagecategorystickers?language=objc)
    pub static SRDeviceUsageCategoryStickers: &'static SRDeviceUsageCategoryKey;
}

extern_class!(
    /// A supplemental category to provide more context than just the app category
    ///
    ///
    /// The app categories from
    /// `SRDeviceUsageCategoryKey`are very general.
    /// Providing a supplemental category allows more context about the specific app while
    /// not revealing the exact app identity.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srsupplementalcategory?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRSupplementalCategory;
);

unsafe impl Send for SRSupplementalCategory {}

unsafe impl Sync for SRSupplementalCategory {}

extern_conformance!(
    unsafe impl NSCoding for SRSupplementalCategory {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRSupplementalCategory {}
);

impl SRSupplementalCategory {
    extern_methods!(
        /// An opaque identifier for the supplemental category
        ///
        /// More information about what this category represents can be found in Apple's developer documentation
        #[unsafe(method(identifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn identifier(&self) -> Retained<NSString>;

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeviceusagereport?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRDeviceUsageReport;
);

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

impl SRDeviceUsageReport {
    extern_methods!(
        /// The duration of this report
        #[unsafe(method(duration))]
        #[unsafe(method_family = none)]
        pub unsafe fn duration(&self) -> NSTimeInterval;

        /// Usage time of applications per category
        ///
        ///
        /// category is the primary genre from the app's iTunesMetadata.plist.
        #[unsafe(method(applicationUsageByCategory))]
        #[unsafe(method_family = none)]
        pub unsafe fn applicationUsageByCategory(
            &self,
        ) -> Retained<NSDictionary<SRDeviceUsageCategoryKey, NSArray<SRApplicationUsage>>>;

        /// Usage time of notifications per category
        ///
        ///
        /// category is the primary genre from the notifying app's iTunesMetadata.plist.
        #[unsafe(method(notificationUsageByCategory))]
        #[unsafe(method_family = none)]
        pub unsafe fn notificationUsageByCategory(
            &self,
        ) -> Retained<NSDictionary<SRDeviceUsageCategoryKey, NSArray<SRNotificationUsage>>>;

        /// Usage time of web domains per category
        ///
        ///
        /// category based on the primary Screen Time category of the web domain
        #[unsafe(method(webUsageByCategory))]
        #[unsafe(method_family = none)]
        pub unsafe fn webUsageByCategory(
            &self,
        ) -> Retained<NSDictionary<SRDeviceUsageCategoryKey, NSArray<SRWebUsage>>>;

        /// Total number of screen wakes over this duration
        #[unsafe(method(totalScreenWakes))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalScreenWakes(&self) -> NSInteger;

        /// Total number of unlocks over this duration
        #[unsafe(method(totalUnlocks))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalUnlocks(&self) -> NSInteger;

        /// Total amount of time the device was unlocked over this duration
        #[unsafe(method(totalUnlockDuration))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalUnlockDuration(&self) -> NSTimeInterval;

        /// Version of the algorithm used to produce the report
        #[unsafe(method(version))]
        #[unsafe(method_family = none)]
        pub unsafe fn version(&self) -> Retained<NSString>;
    );
}

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

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

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srtextinputsessiontype?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRTextInputSessionType(pub NSInteger);
impl SRTextInputSessionType {
    #[doc(alias = "SRTextInputSessionTypeKeyboard")]
    pub const Keyboard: Self = Self(1);
    #[doc(alias = "SRTextInputSessionTypeThirdPartyKeyboard")]
    pub const ThirdPartyKeyboard: Self = Self(2);
    #[doc(alias = "SRTextInputSessionTypePencil")]
    pub const Pencil: Self = Self(3);
    #[doc(alias = "SRTextInputSessionTypeDictation")]
    pub const Dictation: Self = Self(4);
}

unsafe impl Encode for SRTextInputSessionType {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srtextinputsession?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRTextInputSession;
);

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

impl SRTextInputSession {
    extern_methods!(
        #[unsafe(method(duration))]
        #[unsafe(method_family = none)]
        pub unsafe fn duration(&self) -> NSTimeInterval;

        #[unsafe(method(sessionType))]
        #[unsafe(method_family = none)]
        pub unsafe fn sessionType(&self) -> SRTextInputSessionType;

        /// Unique identifier of keyboard session
        #[unsafe(method(sessionIdentifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn sessionIdentifier(&self) -> Retained<NSString>;
    );
}

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

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srapplicationusage?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRApplicationUsage;
);

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

impl SRApplicationUsage {
    extern_methods!(
        /// The bundle identifier of the app in use. Only populated for Apple apps.
        #[unsafe(method(bundleIdentifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn bundleIdentifier(&self) -> Option<Retained<NSString>>;

        /// The amount of time the app is used
        #[unsafe(method(usageTime))]
        #[unsafe(method_family = none)]
        pub unsafe fn usageTime(&self) -> NSTimeInterval;

        /// An application identifier that is valid for the duration of the report.
        ///
        ///
        /// This is useful for identifying distinct application uses within the same
        /// report duration without revealing the actual application identifier.
        #[unsafe(method(reportApplicationIdentifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn reportApplicationIdentifier(&self) -> Retained<NSString>;

        /// The text input session types that occurred during this application usage
        ///
        ///
        /// The list of text input sessions describes the order and type of text input that may
        /// have occured during an application usage. Multiple sessions of the same text input
        /// type will appear as separate array entries. If no text input occurred, this array
        /// will be empty.
        #[unsafe(method(textInputSessions))]
        #[unsafe(method_family = none)]
        pub unsafe fn textInputSessions(&self) -> Retained<NSArray<SRTextInputSession>>;

        /// Additional categories that describe this app
        #[unsafe(method(supplementalCategories))]
        #[unsafe(method_family = none)]
        pub unsafe fn supplementalCategories(&self) -> Retained<NSArray<SRSupplementalCategory>>;

        /// App start time relative to the first app start time in the report interval
        ///
        ///
        /// relativeStartTime value for the very first app in the report interval is equal to 0, N seconds for the seccond app and so on.
        /// This will allow to order app uses and determine the time between app uses.
        #[unsafe(method(relativeStartTime))]
        #[unsafe(method_family = none)]
        pub unsafe fn relativeStartTime(&self) -> NSTimeInterval;
    );
}

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

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

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srnotificationevent?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRNotificationEvent(pub NSInteger);
impl SRNotificationEvent {
    #[doc(alias = "SRNotificationEventUnknown")]
    pub const Unknown: Self = Self(0);
    #[doc(alias = "SRNotificationEventReceived")]
    pub const Received: Self = Self(1);
    #[doc(alias = "SRNotificationEventDefaultAction")]
    pub const DefaultAction: Self = Self(2);
    #[doc(alias = "SRNotificationEventSupplementaryAction")]
    pub const SupplementaryAction: Self = Self(3);
    #[doc(alias = "SRNotificationEventClear")]
    pub const Clear: Self = Self(4);
    #[doc(alias = "SRNotificationEventNotificationCenterClearAll")]
    pub const NotificationCenterClearAll: Self = Self(5);
    #[doc(alias = "SRNotificationEventRemoved")]
    pub const Removed: Self = Self(6);
    #[doc(alias = "SRNotificationEventHide")]
    pub const Hide: Self = Self(7);
    #[doc(alias = "SRNotificationEventLongLook")]
    pub const LongLook: Self = Self(8);
    #[doc(alias = "SRNotificationEventSilence")]
    pub const Silence: Self = Self(9);
    #[doc(alias = "SRNotificationEventAppLaunch")]
    pub const AppLaunch: Self = Self(10);
    #[doc(alias = "SRNotificationEventExpired")]
    pub const Expired: Self = Self(11);
    #[doc(alias = "SRNotificationEventBannerPulldown")]
    pub const BannerPulldown: Self = Self(12);
    #[doc(alias = "SRNotificationEventTapCoalesce")]
    pub const TapCoalesce: Self = Self(13);
    #[doc(alias = "SRNotificationEventDeduped")]
    pub const Deduped: Self = Self(14);
    #[doc(alias = "SRNotificationEventDeviceActivated")]
    pub const DeviceActivated: Self = Self(15);
    #[doc(alias = "SRNotificationEventDeviceUnlocked")]
    pub const DeviceUnlocked: Self = Self(16);
}

unsafe impl Encode for SRNotificationEvent {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srnotificationusage?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRNotificationUsage;
);

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

impl SRNotificationUsage {
    extern_methods!(
        /// The bundle identifier of the application that corresponds to the notification. Only populated for Apple apps.
        #[unsafe(method(bundleIdentifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn bundleIdentifier(&self) -> Option<Retained<NSString>>;

        #[unsafe(method(event))]
        #[unsafe(method_family = none)]
        pub unsafe fn event(&self) -> SRNotificationEvent;
    );
}

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

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srwebusage?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRWebUsage;
);

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

impl SRWebUsage {
    extern_methods!(
        #[unsafe(method(totalUsageTime))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalUsageTime(&self) -> NSTimeInterval;
    );
}

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

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srmessagesusagereport?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRMessagesUsageReport;
);

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

impl SRMessagesUsageReport {
    extern_methods!(
        #[unsafe(method(duration))]
        #[unsafe(method_family = none)]
        pub unsafe fn duration(&self) -> NSTimeInterval;

        #[unsafe(method(totalOutgoingMessages))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalOutgoingMessages(&self) -> NSInteger;

        #[unsafe(method(totalIncomingMessages))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalIncomingMessages(&self) -> NSInteger;

        #[unsafe(method(totalUniqueContacts))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalUniqueContacts(&self) -> NSInteger;
    );
}

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

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphoneusagereport?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRPhoneUsageReport;
);

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

impl SRPhoneUsageReport {
    extern_methods!(
        #[unsafe(method(duration))]
        #[unsafe(method_family = none)]
        pub unsafe fn duration(&self) -> NSTimeInterval;

        #[unsafe(method(totalOutgoingCalls))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalOutgoingCalls(&self) -> NSInteger;

        #[unsafe(method(totalIncomingCalls))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalIncomingCalls(&self) -> NSInteger;

        #[unsafe(method(totalUniqueContacts))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalUniqueContacts(&self) -> NSInteger;

        #[unsafe(method(totalPhoneCallDuration))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalPhoneCallDuration(&self) -> NSTimeInterval;
    );
}

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

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srkeyboardmetrics?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRKeyboardMetrics;
);

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

impl SRKeyboardMetrics {
    extern_methods!(
        /// The duration over which these metrics were calculated
        #[unsafe(method(duration))]
        #[unsafe(method_family = none)]
        pub unsafe fn duration(&self) -> NSTimeInterval;

        /// The identifier of the keyboard in the keyboard list
        #[unsafe(method(keyboardIdentifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn keyboardIdentifier(&self) -> Retained<NSString>;

        /// The version of keyboard metrics
        #[unsafe(method(version))]
        #[unsafe(method_family = none)]
        pub unsafe fn version(&self) -> Retained<NSString>;

        /// The width of the keyboard in mm in the session
        #[unsafe(method(width))]
        #[unsafe(method_family = none)]
        pub unsafe fn width(&self) -> Retained<NSMeasurement<NSUnitLength>>;

        /// The height of the keyboard in mm in the session
        #[unsafe(method(height))]
        #[unsafe(method_family = none)]
        pub unsafe fn height(&self) -> Retained<NSMeasurement<NSUnitLength>>;

        /// The input modes used during a keyboard session
        #[unsafe(method(inputModes))]
        #[unsafe(method_family = none)]
        pub unsafe fn inputModes(&self) -> Retained<NSArray<NSString>>;

        /// The keyboard session identifiers. These are the identifiers of the keyboard sessions that contributed to keyboard metrics sample to correlate current stream with another stream using the same keyboard session indentifiers
        #[unsafe(method(sessionIdentifiers))]
        #[unsafe(method_family = none)]
        pub unsafe fn sessionIdentifiers(&self) -> Retained<NSArray<NSString>>;
    );
}

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

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

/// ScalarMetrics.
impl SRKeyboardMetrics {
    extern_methods!(
        /// The total number of words typed during the session
        #[unsafe(method(totalWords))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalWords(&self) -> NSInteger;

        /// The total number of altered words during the session
        #[unsafe(method(totalAlteredWords))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalAlteredWords(&self) -> NSInteger;

        /// The total number of taps during the session
        #[unsafe(method(totalTaps))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalTaps(&self) -> NSInteger;

        /// The total number of drags during the session
        #[unsafe(method(totalDrags))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalDrags(&self) -> NSInteger;

        /// The total number of deletes during the session
        #[unsafe(method(totalDeletes))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalDeletes(&self) -> NSInteger;

        /// The total number of emojis used during the session
        #[unsafe(method(totalEmojis))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalEmojis(&self) -> NSInteger;

        /// The total number of paths used during the sesion
        #[unsafe(method(totalPaths))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalPaths(&self) -> NSInteger;

        /// The total time taken to complete paths in the session
        #[unsafe(method(totalPathTime))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalPathTime(&self) -> NSTimeInterval;

        /// The total length of paths completed in the session
        #[unsafe(method(totalPathLength))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalPathLength(&self) -> Retained<NSMeasurement<NSUnitLength>>;

        /// The total number of autocorrections in the session
        #[unsafe(method(totalAutoCorrections))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalAutoCorrections(&self) -> NSInteger;

        /// The total number of space corrections in the session
        #[unsafe(method(totalSpaceCorrections))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalSpaceCorrections(&self) -> NSInteger;

        /// The total number of retro corrections in the session
        #[unsafe(method(totalRetroCorrections))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalRetroCorrections(&self) -> NSInteger;

        /// The total number of transposition corrections in the session
        #[unsafe(method(totalTranspositionCorrections))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalTranspositionCorrections(&self) -> NSInteger;

        /// The total number of insert key corrections in the session
        #[unsafe(method(totalInsertKeyCorrections))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalInsertKeyCorrections(&self) -> NSInteger;

        /// The total number of skip touch corrections in the session
        #[unsafe(method(totalSkipTouchCorrections))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalSkipTouchCorrections(&self) -> NSInteger;

        /// The total number of near key corrections in the session
        #[unsafe(method(totalNearKeyCorrections))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalNearKeyCorrections(&self) -> NSInteger;

        /// The total number of substitution corrections in the session
        #[unsafe(method(totalSubstitutionCorrections))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalSubstitutionCorrections(&self) -> NSInteger;

        /// The total number of hit test corrections in the session
        #[unsafe(method(totalHitTestCorrections))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalHitTestCorrections(&self) -> NSInteger;

        /// The total amount of time typing during the session
        #[unsafe(method(totalTypingDuration))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalTypingDuration(&self) -> NSTimeInterval;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srkeyboardprobabilitymetric?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRKeyboardProbabilityMetric<UnitType: ?Sized = AnyObject>;
);

extern_conformance!(
    unsafe impl<UnitType: ?Sized> NSObjectProtocol for SRKeyboardProbabilityMetric<UnitType> {}
);

impl<UnitType: Message> SRKeyboardProbabilityMetric<UnitType> {
    extern_methods!(
        /// Sample values from probability distribution
        #[unsafe(method(distributionSampleValues))]
        #[unsafe(method_family = none)]
        pub unsafe fn distributionSampleValues(&self)
            -> Retained<NSArray<NSMeasurement<UnitType>>>;
    );
}

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

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

/// ProbabilityMetrics.
impl SRKeyboardMetrics {
    extern_methods!(
        /// The distance from the touch up to the center of any key
        #[unsafe(method(upErrorDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn upErrorDistance(&self)
            -> Retained<SRKeyboardProbabilityMetric<NSUnitLength>>;

        /// The distance from the touch down to the center of any key
        #[unsafe(method(downErrorDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn downErrorDistance(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitLength>>;

        /// The distance from the touch up to the right centroid of the space key
        #[unsafe(method(spaceUpErrorDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn spaceUpErrorDistance(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitLength>>;

        /// The distance from the touch down to the right centroid of the space key
        #[unsafe(method(spaceDownErrorDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn spaceDownErrorDistance(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitLength>>;

        /// The distance from the touch up to the center of the delete key
        #[unsafe(method(deleteUpErrorDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn deleteUpErrorDistance(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitLength>>;

        /// The distance from the touch down to the center of the delete key
        #[unsafe(method(deleteDownErrorDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn deleteDownErrorDistance(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitLength>>;

        /// The distance from the touch up to the center of the intended key of a character in a short word
        #[unsafe(method(shortWordCharKeyUpErrorDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn shortWordCharKeyUpErrorDistance(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitLength>>;

        /// The distance from the touch down to the center of the intended key of a character in a short word
        #[unsafe(method(shortWordCharKeyDownErrorDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn shortWordCharKeyDownErrorDistance(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitLength>>;

        /// The duration between touch down to touchup for any key
        #[unsafe(method(touchDownUp))]
        #[unsafe(method_family = none)]
        pub unsafe fn touchDownUp(&self) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touch down and touchup of all space key events in the session.
        #[unsafe(method(spaceTouchDownUp))]
        #[unsafe(method_family = none)]
        pub unsafe fn spaceTouchDownUp(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touch down and touchup of all delete key events in the session.
        #[unsafe(method(deleteTouchDownUp))]
        #[unsafe(method_family = none)]
        pub unsafe fn deleteTouchDownUp(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touch down and touchup of all character keys in short words in the session.
        #[unsafe(method(shortWordCharKeyTouchDownUp))]
        #[unsafe(method_family = none)]
        pub unsafe fn shortWordCharKeyTouchDownUp(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touch down to touch down for any key
        #[unsafe(method(touchDownDown))]
        #[unsafe(method_family = none)]
        pub unsafe fn touchDownDown(&self)
            -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touch up and touch down for any key
        #[unsafe(method(touchUpDown))]
        #[unsafe(method_family = none)]
        pub unsafe fn touchUpDown(&self) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup on a character key and touch down on a word in the prediction bar
        #[unsafe(method(charKeyToPrediction))]
        #[unsafe(method_family = none)]
        pub unsafe fn charKeyToPrediction(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup on a character key and touch down on any sequential character key in a short word
        #[unsafe(method(shortWordCharKeyToCharKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn shortWordCharKeyToCharKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup on a character key and touch down on the next sequential key (any key)
        #[unsafe(method(charKeyToAnyTapKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn charKeyToAnyTapKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of any key and touch down on a sequential character key
        #[unsafe(method(anyTapToCharKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn anyTapToCharKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a space key and touch down of a sequential character key
        #[unsafe(method(spaceToCharKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn spaceToCharKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a character key and touch down of a sequential space key
        #[unsafe(method(charKeyToSpaceKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn charKeyToSpaceKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a space key and touch down of a sequential delete key
        #[unsafe(method(spaceToDeleteKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn spaceToDeleteKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a delete key and touch down of a sequential space key
        #[unsafe(method(deleteToSpaceKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn deleteToSpaceKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a space key and touch down of a sequential space key
        #[unsafe(method(spaceToSpaceKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn spaceToSpaceKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a space key and touch down of a sequential Shift key
        #[unsafe(method(spaceToShiftKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn spaceToShiftKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a space key and touch down of a sequential plane change key
        #[unsafe(method(spaceToPlaneChangeKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn spaceToPlaneChangeKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup on the space key and touch down of a sequential selection from the prediction bar
        #[unsafe(method(spaceToPredictionKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn spaceToPredictionKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a delete key and touch down of a sequential character key
        #[unsafe(method(deleteToCharKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn deleteToCharKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a character key and touch down of a sequential delete key
        #[unsafe(method(charKeyToDelete))]
        #[unsafe(method_family = none)]
        pub unsafe fn charKeyToDelete(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a delete key and touch down of a sequential delete key
        #[unsafe(method(deleteToDelete))]
        #[unsafe(method_family = none)]
        pub unsafe fn deleteToDelete(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a delete key and touch down of a sequential Shift key
        #[unsafe(method(deleteToShiftKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn deleteToShiftKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a delete key and touch down of a sequential plane change key
        #[unsafe(method(deleteToPlaneChangeKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn deleteToPlaneChangeKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of any key and touch down on a plane change key
        #[unsafe(method(anyTapToPlaneChangeKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn anyTapToPlaneChangeKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup on a plane change key and touch down on the next sequential key
        #[unsafe(method(planeChangeToAnyTap))]
        #[unsafe(method_family = none)]
        pub unsafe fn planeChangeToAnyTap(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a character key and touch down of a sequential plane change key
        #[unsafe(method(charKeyToPlaneChangeKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn charKeyToPlaneChangeKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a plane change key and touch down of any key
        #[unsafe(method(planeChangeKeyToCharKey))]
        #[unsafe(method_family = none)]
        pub unsafe fn planeChangeKeyToCharKey(
            &self,
        ) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// sample values of the ratio of error distance between intended and actual path
        #[unsafe(method(pathErrorDistanceRatio))]
        #[unsafe(method_family = none)]
        pub unsafe fn pathErrorDistanceRatio(&self) -> Retained<NSArray<NSNumber>>;

        /// The duration between touchup of a delete key and touch down of a sequential path
        #[unsafe(method(deleteToPath))]
        #[unsafe(method_family = none)]
        pub unsafe fn deleteToPath(&self) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a delete key and touch down of a sequential path (ie. Continuous Path)
        #[unsafe(method(pathToDelete))]
        #[unsafe(method_family = none)]
        pub unsafe fn pathToDelete(&self) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup on the space key and touch down to begin a sequential path
        #[unsafe(method(spaceToPath))]
        #[unsafe(method_family = none)]
        pub unsafe fn spaceToPath(&self) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a path and touch down of a sequential space key
        #[unsafe(method(pathToSpace))]
        #[unsafe(method_family = none)]
        pub unsafe fn pathToSpace(&self) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;

        /// The duration between touchup of a path and touch down of a sequential path
        #[unsafe(method(pathToPath))]
        #[unsafe(method_family = none)]
        pub unsafe fn pathToPath(&self) -> Retained<SRKeyboardProbabilityMetric<NSUnitDuration>>;
    );
}

/// PositionalMetrics.
/// Probability metrics for each character in a word in their respective positions (first, second, third, fourth, fifth, and the rest)
impl SRKeyboardMetrics {
    extern_methods!(
        /// The distance from the touch up to the center of the intended key of the characters of a long word
        #[unsafe(method(longWordUpErrorDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn longWordUpErrorDistance(
            &self,
        ) -> Retained<NSArray<SRKeyboardProbabilityMetric<NSUnitLength>>>;

        /// The distance from the touch down to the center of the intended key of the characters of a long word
        #[unsafe(method(longWordDownErrorDistance))]
        #[unsafe(method_family = none)]
        pub unsafe fn longWordDownErrorDistance(
            &self,
        ) -> Retained<NSArray<SRKeyboardProbabilityMetric<NSUnitLength>>>;

        /// The duration between touch down and touchup of the character keys of all the long words in the session.
        #[unsafe(method(longWordTouchDownUp))]
        #[unsafe(method_family = none)]
        pub unsafe fn longWordTouchDownUp(
            &self,
        ) -> Retained<NSArray<SRKeyboardProbabilityMetric<NSUnitDuration>>>;

        /// The duration between touch down and touch down of the character keys of all the long words in the session.
        #[unsafe(method(longWordTouchDownDown))]
        #[unsafe(method_family = none)]
        pub unsafe fn longWordTouchDownDown(
            &self,
        ) -> Retained<NSArray<SRKeyboardProbabilityMetric<NSUnitDuration>>>;

        /// The duration between touch up and touch down of the character keys of all the long words in the session.
        #[unsafe(method(longWordTouchUpDown))]
        #[unsafe(method_family = none)]
        pub unsafe fn longWordTouchUpDown(
            &self,
        ) -> Retained<NSArray<SRKeyboardProbabilityMetric<NSUnitDuration>>>;

        /// The duration between touchup of the delete key and touch down of a sequential delete key
        #[unsafe(method(deleteToDeletes))]
        #[unsafe(method_family = none)]
        pub unsafe fn deleteToDeletes(
            &self,
        ) -> Retained<NSArray<SRKeyboardProbabilityMetric<NSUnitDuration>>>;
    );
}

/// SpeedMetrics.
impl SRKeyboardMetrics {
    extern_methods!(
        /// The total number of pauses during the session
        #[unsafe(method(totalPauses))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalPauses(&self) -> NSInteger;

        /// The total number of pauses made while entering the path for any words composed using continuous path during the session
        #[unsafe(method(totalPathPauses))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalPathPauses(&self) -> NSInteger;

        /// The words per minute typed during the session
        #[unsafe(method(typingSpeed))]
        #[unsafe(method_family = none)]
        pub unsafe fn typingSpeed(&self) -> c_double;

        /// The words per minute typed using continuous path during the session
        #[unsafe(method(pathTypingSpeed))]
        #[unsafe(method_family = none)]
        pub unsafe fn pathTypingSpeed(&self) -> c_double;

        /// Total number of continuous typing episodes during the session
        #[unsafe(method(totalTypingEpisodes))]
        #[unsafe(method_family = none)]
        pub unsafe fn totalTypingEpisodes(&self) -> NSInteger;
    );
}

/// Categories of sentiment from words or emoji
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srkeyboardmetricssentimentcategory?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRKeyboardMetricsSentimentCategory(pub NSInteger);
impl SRKeyboardMetricsSentimentCategory {
    #[doc(alias = "SRKeyboardMetricsSentimentCategoryAbsolutist")]
    pub const Absolutist: Self = Self(0);
    #[doc(alias = "SRKeyboardMetricsSentimentCategoryDown")]
    pub const Down: Self = Self(1);
    #[doc(alias = "SRKeyboardMetricsSentimentCategoryDeath")]
    pub const Death: Self = Self(2);
    #[doc(alias = "SRKeyboardMetricsSentimentCategoryAnxiety")]
    pub const Anxiety: Self = Self(3);
    #[doc(alias = "SRKeyboardMetricsSentimentCategoryAnger")]
    pub const Anger: Self = Self(4);
    #[doc(alias = "SRKeyboardMetricsSentimentCategoryHealth")]
    pub const Health: Self = Self(5);
    #[doc(alias = "SRKeyboardMetricsSentimentCategoryPositive")]
    pub const Positive: Self = Self(6);
    #[doc(alias = "SRKeyboardMetricsSentimentCategorySad")]
    pub const Sad: Self = Self(7);
    #[doc(alias = "SRKeyboardMetricsSentimentCategoryLowEnergy")]
    pub const LowEnergy: Self = Self(8);
    #[doc(alias = "SRKeyboardMetricsSentimentCategoryConfused")]
    pub const Confused: Self = Self(9);
}

unsafe impl Encode for SRKeyboardMetricsSentimentCategory {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

/// SentimentCounts.
/// These metrics describe the number of words and emoji of a particular category typed during
/// a keyboard session. Words and emoji may be counted in multiple categories.
impl SRKeyboardMetrics {
    extern_methods!(
        /// The count of words typed per category in the session
        #[unsafe(method(wordCountForSentimentCategory:))]
        #[unsafe(method_family = none)]
        pub unsafe fn wordCountForSentimentCategory(
            &self,
            category: SRKeyboardMetricsSentimentCategory,
        ) -> NSInteger;

        /// The count of emoji typed per category in the session
        #[unsafe(method(emojiCountForSentimentCategory:))]
        #[unsafe(method_family = none)]
        pub unsafe fn emojiCountForSentimentCategory(
            &self,
            category: SRKeyboardMetricsSentimentCategory,
        ) -> NSInteger;
    );
}

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeletionreason?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRDeletionReason(pub NSInteger);
impl SRDeletionReason {
    /// The user initiated deletion
    #[doc(alias = "SRDeletionReasonUserInitiated")]
    pub const UserInitiated: Self = Self(0);
    /// Samples were removed due to low disk conditions
    #[doc(alias = "SRDeletionReasonLowDiskSpace")]
    pub const LowDiskSpace: Self = Self(1);
    /// Samples were removed because they were recorded beyond our retention limit
    #[doc(alias = "SRDeletionReasonAgeLimit")]
    pub const AgeLimit: Self = Self(2);
    /// Samples were removed because there are no longer any interested clients
    #[doc(alias = "SRDeletionReasonNoInterestedClients")]
    pub const NoInterestedClients: Self = Self(3);
    /// Samples were removed because the system was in an invalid state
    #[doc(alias = "SRDeletionReasonSystemInitiated")]
    pub const SystemInitiated: Self = Self(4);
}

unsafe impl Encode for SRDeletionReason {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srdeletionrecord?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRDeletionRecord;
);

extern_conformance!(
    unsafe impl NSCoding for SRDeletionRecord {}
);

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRDeletionRecord {}
);

impl SRDeletionRecord {
    extern_methods!(
        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(startTime))]
        #[unsafe(method_family = none)]
        pub unsafe fn startTime(&self) -> SRAbsoluteTime;

        #[cfg(feature = "objc2-core-foundation")]
        #[unsafe(method(endTime))]
        #[unsafe(method_family = none)]
        pub unsafe fn endTime(&self) -> SRAbsoluteTime;

        #[unsafe(method(reason))]
        #[unsafe(method_family = none)]
        pub unsafe fn reason(&self) -> SRDeletionReason;
    );
}

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

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

mod private_NSStringSRDeletionRecord {
    pub trait Sealed {}
}

/// Category "SRDeletionRecord" on [`NSString`].
#[doc(alias = "SRDeletionRecord")]
pub unsafe trait NSStringSRDeletionRecord:
    ClassType + Sized + private_NSStringSRDeletionRecord::Sealed
{
    extern_methods!(
        /// Returns a sensor stream that contains deletion records of the sensor
        ///
        ///
        /// This sensor stream should only be used for fetching. All other
        /// operations will be ignored. Deletion records share the recording and authorization
        /// state with their parent sensor.
        ///
        ///
        /// Returns: May return nil if there is no deletion record available for this sensor
        #[unsafe(method(sr_sensorForDeletionRecordsFromSensor))]
        #[unsafe(method_family = none)]
        unsafe fn sr_sensorForDeletionRecordsFromSensor(&self) -> Option<Retained<SRSensor>>;
    );
}

impl private_NSStringSRDeletionRecord::Sealed for NSString {}
unsafe impl NSStringSRDeletionRecord for NSString {}

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srwristlocation?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRWristLocation(pub NSInteger);
impl SRWristLocation {
    #[doc(alias = "SRWristLocationLeft")]
    pub const Left: Self = Self(0);
    #[doc(alias = "SRWristLocationRight")]
    pub const Right: Self = Self(1);
}

unsafe impl Encode for SRWristLocation {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srcrownorientation?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRCrownOrientation(pub NSInteger);
impl SRCrownOrientation {
    #[doc(alias = "SRCrownOrientationLeft")]
    pub const Left: Self = Self(0);
    #[doc(alias = "SRCrownOrientationRight")]
    pub const Right: Self = Self(1);
}

unsafe impl Encode for SRCrownOrientation {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srwristdetection?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRWristDetection;
);

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

impl SRWristDetection {
    extern_methods!(
        #[unsafe(method(onWrist))]
        #[unsafe(method_family = none)]
        pub unsafe fn onWrist(&self) -> bool;

        #[unsafe(method(wristLocation))]
        #[unsafe(method_family = none)]
        pub unsafe fn wristLocation(&self) -> SRWristLocation;

        #[unsafe(method(crownOrientation))]
        #[unsafe(method_family = none)]
        pub unsafe fn crownOrientation(&self) -> SRCrownOrientation;

        /// Start date of the recent on-wrist state.
        ///
        ///
        /// - When the state changes from off-wrist to on-wrist, onWristDate would be updated to the current date, and offWristDate would remain the same.
        /// - When the state changes from on-wrist to off-wrist, offWristDate would be updated to the current date, and onWristDate would remain the same.
        #[unsafe(method(onWristDate))]
        #[unsafe(method_family = none)]
        pub unsafe fn onWristDate(&self) -> Option<Retained<NSDate>>;

        /// Start date of the recent off-wrist state.
        ///
        ///
        /// - When the state changes from off-wrist to on-wrist, onWristDate would be updated to the current date, and offWristDate would remain the same.
        /// - When the state changes from on-wrist to off-wrist, offWristDate would be updated to the current date, and onWristDate would remain the same.
        #[unsafe(method(offWristDate))]
        #[unsafe(method_family = none)]
        pub unsafe fn offWristDate(&self) -> Option<Retained<NSDate>>;
    );
}

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

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

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srwristtemperaturecondition?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRWristTemperatureCondition(pub NSUInteger);
bitflags::bitflags! {
    impl SRWristTemperatureCondition: NSUInteger {
        #[doc(alias = "SRWristTemperatureConditionNone")]
        const None = 0;
        #[doc(alias = "SRWristTemperatureConditionOffWrist")]
        const OffWrist = 1<<0;
        #[doc(alias = "SRWristTemperatureConditionOnCharger")]
        const OnCharger = 1<<1;
        #[doc(alias = "SRWristTemperatureConditionInMotion")]
        const InMotion = 1<<2;
    }
}

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

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srwristtemperature?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRWristTemperature;
);

unsafe impl Send for SRWristTemperature {}

unsafe impl Sync for SRWristTemperature {}

extern_conformance!(
    unsafe impl NSCoding for SRWristTemperature {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRWristTemperature {}
);

impl SRWristTemperature {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        /// Timestamp of when temperature measurement was taken.
        #[unsafe(method(timestamp))]
        #[unsafe(method_family = none)]
        pub unsafe fn timestamp(&self) -> Retained<NSDate>;

        /// Temperature sensor value in celsius
        #[unsafe(method(value))]
        #[unsafe(method_family = none)]
        pub unsafe fn value(&self) -> Retained<NSMeasurement<NSUnitTemperature>>;

        /// Indicate system conditions that may impact the temperature sample.
        #[unsafe(method(condition))]
        #[unsafe(method_family = none)]
        pub unsafe fn condition(&self) -> SRWristTemperatureCondition;

        /// Estimated temperature error per sample.
        /// Error could be in either positive or negative direction.
        #[unsafe(method(errorEstimate))]
        #[unsafe(method_family = none)]
        pub unsafe fn errorEstimate(&self) -> Retained<NSMeasurement<NSUnitTemperature>>;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srwristtemperaturesession?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRWristTemperatureSession;
);

unsafe impl Send for SRWristTemperatureSession {}

unsafe impl Sync for SRWristTemperatureSession {}

extern_conformance!(
    unsafe impl NSCoding for SRWristTemperatureSession {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRWristTemperatureSession {}
);

impl SRWristTemperatureSession {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        /// Indicates when temperatures were collected.
        #[unsafe(method(startDate))]
        #[unsafe(method_family = none)]
        pub unsafe fn startDate(&self) -> Retained<NSDate>;

        /// Precise number of seconds temperatures were collected.
        #[unsafe(method(duration))]
        #[unsafe(method_family = none)]
        pub unsafe fn duration(&self) -> NSTimeInterval;

        /// Algorithm version.
        #[unsafe(method(version))]
        #[unsafe(method_family = none)]
        pub unsafe fn version(&self) -> Retained<NSString>;

        /// Enumerator which could be used to view calculated wrist temperatures, along with their reading accuracy.
        #[unsafe(method(temperatures))]
        #[unsafe(method_family = none)]
        pub unsafe fn temperatures(&self) -> Retained<NSEnumerator<SRWristTemperature>>;
    );
}

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srmediaeventtype?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRMediaEventType(pub NSInteger);
impl SRMediaEventType {
    #[doc(alias = "SRMediaEventOnScreen")]
    pub const OnScreen: Self = Self(1);
    #[doc(alias = "SRMediaEventOffScreen")]
    pub const OffScreen: Self = Self(2);
}

unsafe impl Encode for SRMediaEventType {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srmediaevent?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRMediaEvent;
);

unsafe impl Send for SRMediaEvent {}

unsafe impl Sync for SRMediaEvent {}

extern_conformance!(
    unsafe impl NSCoding for SRMediaEvent {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRMediaEvent {}
);

impl SRMediaEvent {
    extern_methods!(
        /// Unique media identifier
        ///
        ///
        /// Unique media identifier to track a specific media object.
        #[unsafe(method(mediaIdentifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn mediaIdentifier(&self) -> Retained<NSString>;

        /// Type of the event
        ///
        ///
        /// Type of media event (e.g., media has been displayed on a screen).
        #[unsafe(method(eventType))]
        #[unsafe(method_family = none)]
        pub unsafe fn eventType(&self) -> SRMediaEventType;
    );
}

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

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srspeechexpression?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRSpeechExpression;
);

unsafe impl Send for SRSpeechExpression {}

unsafe impl Sync for SRSpeechExpression {}

extern_conformance!(
    unsafe impl NSCoding for SRSpeechExpression {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRSpeechExpression {}
);

impl SRSpeechExpression {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        /// Version of the algorithm used to generate
        /// `SRSpeechExpression`
        #[unsafe(method(version))]
        #[unsafe(method_family = none)]
        pub unsafe fn version(&self) -> Retained<NSString>;

        #[cfg(feature = "objc2-core-media")]
        /// The time range in the client-provided audio stream to which this classification
        /// result corresponds
        #[unsafe(method(timeRange))]
        #[unsafe(method_family = none)]
        pub unsafe fn timeRange(&self) -> CMTimeRange;

        /// The level of confidence normalized to [0, 1], where 1 is most confident
        #[unsafe(method(confidence))]
        #[unsafe(method_family = none)]
        pub unsafe fn confidence(&self) -> c_double;

        /// Indicator of how slurry/tired/exhausted the speaker sounds as opposed to normal.
        ///
        ///
        /// on a scale from -1 to 1, where negative scores indicate 'negative'
        /// sentiment, and positive scores indicate 'positive' sentiment.
        #[unsafe(method(mood))]
        #[unsafe(method_family = none)]
        pub unsafe fn mood(&self) -> c_double;

        /// Degree of (perceived) positive or negative emotion/sentiment from voice
        ///
        ///
        /// on a scale from -1 to 1, where negative scores indicate 'negative'
        /// sentiment, and positive scores indicate 'positive' sentiment.
        #[unsafe(method(valence))]
        #[unsafe(method_family = none)]
        pub unsafe fn valence(&self) -> c_double;

        /// Level of energy or activation (perceived) in voice
        ///
        ///
        /// on a scale from -1 to 1, where negative scores indicate 'negative'
        /// sentiment, and positive scores indicate 'positive' sentiment.
        #[unsafe(method(activation))]
        #[unsafe(method_family = none)]
        pub unsafe fn activation(&self) -> c_double;

        /// Degree of how strong or meek a person sounds (perceptually)
        ///
        ///
        /// on a scale from -1 to 1, where negative scores indicate 'negative'
        /// sentiment, and positive scores indicate 'positive' sentiment.
        #[unsafe(method(dominance))]
        #[unsafe(method_family = none)]
        pub unsafe fn dominance(&self) -> c_double;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/sraudiolevel?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRAudioLevel;
);

unsafe impl Send for SRAudioLevel {}

unsafe impl Sync for SRAudioLevel {}

extern_conformance!(
    unsafe impl NSCoding for SRAudioLevel {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRAudioLevel {}
);

impl SRAudioLevel {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        #[cfg(feature = "objc2-core-media")]
        /// The time range in the client-provided audio stream to which this classification
        /// result corresponds
        #[unsafe(method(timeRange))]
        #[unsafe(method_family = none)]
        pub unsafe fn timeRange(&self) -> CMTimeRange;

        /// Measure of the audio level in decibels
        #[unsafe(method(loudness))]
        #[unsafe(method_family = none)]
        pub unsafe fn loudness(&self) -> c_double;
    );
}

/// Flags indicating more information about how audio processing was done
/// on the audio stream
///
///
///
/// Audio stream went through the system voice processor
///
///
///
/// Audio stream bypassed the system voice processor.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srspeechmetricssessionflags?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRSpeechMetricsSessionFlags(pub NSUInteger);
bitflags::bitflags! {
    impl SRSpeechMetricsSessionFlags: NSUInteger {
        #[doc(alias = "SRSpeechMetricsSessionFlagsDefault")]
        const Default = 0;
        #[doc(alias = "SRSpeechMetricsSessionFlagsBypassVoiceProcessing")]
        const BypassVoiceProcessing = 1<<0;
    }
}

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

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srspeechmetrics?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRSpeechMetrics;
);

unsafe impl Send for SRSpeechMetrics {}

unsafe impl Sync for SRSpeechMetrics {}

extern_conformance!(
    unsafe impl NSCoding for SRSpeechMetrics {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRSpeechMetrics {}
);

impl SRSpeechMetrics {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        /// Identifier of an audio session e.g., a Phone call or Siri utterance
        #[unsafe(method(sessionIdentifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn sessionIdentifier(&self) -> Retained<NSString>;

        #[unsafe(method(sessionFlags))]
        #[unsafe(method_family = none)]
        pub unsafe fn sessionFlags(&self) -> SRSpeechMetricsSessionFlags;

        /// The wall time when this sample was generated
        #[unsafe(method(timestamp))]
        #[unsafe(method_family = none)]
        pub unsafe fn timestamp(&self) -> Retained<NSDate>;

        /// The number of seconds since the start of the audio stream
        ///
        ///
        /// When an audio stream like a phone call starts,
        /// `SRSpeechMetrics`samples are collected
        /// periodically. This field can be used to determine where each sample falls in the audio stream
        #[unsafe(method(timeSinceAudioStart))]
        #[unsafe(method_family = none)]
        pub unsafe fn timeSinceAudioStart(&self) -> NSTimeInterval;

        #[unsafe(method(audioLevel))]
        #[unsafe(method_family = none)]
        pub unsafe fn audioLevel(&self) -> Option<Retained<SRAudioLevel>>;

        #[cfg(feature = "objc2-speech")]
        #[unsafe(method(speechRecognition))]
        #[unsafe(method_family = none)]
        pub unsafe fn speechRecognition(&self) -> Option<Retained<SFSpeechRecognitionResult>>;

        #[cfg(feature = "objc2-sound-analysis")]
        #[unsafe(method(soundClassification))]
        #[unsafe(method_family = none)]
        pub unsafe fn soundClassification(&self) -> Option<Retained<SNClassificationResult>>;

        #[unsafe(method(speechExpression))]
        #[unsafe(method_family = none)]
        pub unsafe fn speechExpression(&self) -> Option<Retained<SRSpeechExpression>>;
    );
}

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srfacemetricscontext?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRFaceMetricsContext(pub NSUInteger);
bitflags::bitflags! {
    impl SRFaceMetricsContext: NSUInteger {
        #[doc(alias = "SRFaceMetricsContextDeviceUnlock")]
        const DeviceUnlock = 1<<0;
        #[doc(alias = "SRFaceMetricsContextMessagingAppUsage")]
        const MessagingAppUsage = 1<<1;
    }
}

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

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srfacemetricsexpression?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRFaceMetricsExpression;
);

unsafe impl Send for SRFaceMetricsExpression {}

unsafe impl Sync for SRFaceMetricsExpression {}

extern_conformance!(
    unsafe impl NSCoding for SRFaceMetricsExpression {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRFaceMetricsExpression {}
);

impl SRFaceMetricsExpression {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        /// An opaque identifier for the face expression
        ///
        /// More information about what this face expression represents can be found in Apple's developer documentation
        #[unsafe(method(identifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn identifier(&self) -> Retained<NSString>;

        /// double value indicating the current position of the expression
        #[unsafe(method(value))]
        #[unsafe(method_family = none)]
        pub unsafe fn value(&self) -> c_double;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srfacemetrics?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRFaceMetrics;
);

unsafe impl Send for SRFaceMetrics {}

unsafe impl Sync for SRFaceMetrics {}

extern_conformance!(
    unsafe impl NSCoding for SRFaceMetrics {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRFaceMetrics {}
);

impl SRFaceMetrics {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        /// Algorithm version
        #[unsafe(method(version))]
        #[unsafe(method_family = none)]
        pub unsafe fn version(&self) -> Retained<NSString>;

        /// Identifier of a camera session
        #[unsafe(method(sessionIdentifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn sessionIdentifier(&self) -> Retained<NSString>;

        /// Indicates system context during a camera session, e.g., if the device was unlocked or (and) a messaging app was used
        #[unsafe(method(context))]
        #[unsafe(method_family = none)]
        pub unsafe fn context(&self) -> SRFaceMetricsContext;

        #[cfg(feature = "objc2-ar-kit")]
        #[unsafe(method(faceAnchor))]
        #[unsafe(method_family = none)]
        pub unsafe fn faceAnchor(&self) -> Retained<ARFaceAnchor>;

        /// Detected whole face expressions
        #[unsafe(method(wholeFaceExpressions))]
        #[unsafe(method_family = none)]
        pub unsafe fn wholeFaceExpressions(&self) -> Retained<NSArray<SRFaceMetricsExpression>>;

        /// Detected partial face expressions
        #[unsafe(method(partialFaceExpressions))]
        #[unsafe(method_family = none)]
        pub unsafe fn partialFaceExpressions(&self) -> Retained<NSArray<SRFaceMetricsExpression>>;
    );
}

/// The state of the ECG session when this sample was taken
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srelectrocardiogramsessionstate?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRElectrocardiogramSessionState(pub NSInteger);
impl SRElectrocardiogramSessionState {
    #[doc(alias = "SRElectrocardiogramSessionStateBegin")]
    pub const Begin: Self = Self(1);
    #[doc(alias = "SRElectrocardiogramSessionStateActive")]
    pub const Active: Self = Self(2);
    #[doc(alias = "SRElectrocardiogramSessionStateEnd")]
    pub const End: Self = Self(3);
}

unsafe impl Encode for SRElectrocardiogramSessionState {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

/// The type of session used to record the ECG sample
///
///
///
/// A session, usually of fixed duration, where the user is provided coaching to guide the ECG readings
///
///
///
/// A session, usually of undefined duration, where the user is not provided coaching to guide the ECG readings
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srelectrocardiogramsessionguidance?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRElectrocardiogramSessionGuidance(pub NSInteger);
impl SRElectrocardiogramSessionGuidance {
    #[doc(alias = "SRElectrocardiogramSessionGuidanceGuided")]
    pub const Guided: Self = Self(1);
    #[doc(alias = "SRElectrocardiogramSessionGuidanceUnguided")]
    pub const Unguided: Self = Self(2);
}

unsafe impl Encode for SRElectrocardiogramSessionGuidance {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srelectrocardiogramsession?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRElectrocardiogramSession;
);

unsafe impl Send for SRElectrocardiogramSession {}

unsafe impl Sync for SRElectrocardiogramSession {}

extern_conformance!(
    unsafe impl NSCoding for SRElectrocardiogramSession {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRElectrocardiogramSession {}
);

impl SRElectrocardiogramSession {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        /// The state of the ECG session when the sample was recorded
        #[unsafe(method(state))]
        #[unsafe(method_family = none)]
        pub unsafe fn state(&self) -> SRElectrocardiogramSessionState;

        /// The type of session guidance during the the ECG session
        #[unsafe(method(sessionGuidance))]
        #[unsafe(method_family = none)]
        pub unsafe fn sessionGuidance(&self) -> SRElectrocardiogramSessionGuidance;

        /// Used to tie samples across multiple
        /// `SRFetchResult`s to the same session
        #[unsafe(method(identifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn identifier(&self) -> Retained<NSString>;
    );
}

/// Flags indicating sensor context or events that occurred during
/// the sample reading
///
///
/// These flags can provide some indication of data validity or other system conditions
/// that may influence how the recorded data should be treated.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srelectrocardiogramdataflags?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRElectrocardiogramDataFlags(pub NSUInteger);
bitflags::bitflags! {
    impl SRElectrocardiogramDataFlags: NSUInteger {
        #[doc(alias = "SRElectrocardiogramDataFlagsNone")]
        const None = 0;
/// Indicates an invalid sensor signal in the ECG data
        #[doc(alias = "SRElectrocardiogramDataFlagsSignalInvalid")]
        const SignalInvalid = 1<<0;
/// Indicates ECG data was recorded when the crown was being touched
        #[doc(alias = "SRElectrocardiogramDataFlagsCrownTouched")]
        const CrownTouched = 1<<1;
    }
}

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

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srelectrocardiogramdata?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRElectrocardiogramData;
);

unsafe impl Send for SRElectrocardiogramData {}

unsafe impl Sync for SRElectrocardiogramData {}

extern_conformance!(
    unsafe impl NSCoding for SRElectrocardiogramData {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRElectrocardiogramData {}
);

impl SRElectrocardiogramData {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        #[unsafe(method(flags))]
        #[unsafe(method_family = none)]
        pub unsafe fn flags(&self) -> SRElectrocardiogramDataFlags;

        /// Value of the ECG AC data in microvolts
        #[unsafe(method(value))]
        #[unsafe(method_family = none)]
        pub unsafe fn value(&self) -> Retained<NSMeasurement<NSUnitElectricPotentialDifference>>;
    );
}

/// Which lead was used to record the ECG data
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srelectrocardiogramlead?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct SRElectrocardiogramLead(pub NSInteger);
impl SRElectrocardiogramLead {
    #[doc(alias = "SRElectrocardiogramLeadRightArmMinusLeftArm")]
    pub const RightArmMinusLeftArm: Self = Self(1);
    #[doc(alias = "SRElectrocardiogramLeadLeftArmMinusRightArm")]
    pub const LeftArmMinusRightArm: Self = Self(2);
}

unsafe impl Encode for SRElectrocardiogramLead {
    const ENCODING: Encoding = NSInteger::ENCODING;
}

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

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srelectrocardiogramsample?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRElectrocardiogramSample;
);

unsafe impl Send for SRElectrocardiogramSample {}

unsafe impl Sync for SRElectrocardiogramSample {}

extern_conformance!(
    unsafe impl NSCoding for SRElectrocardiogramSample {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRElectrocardiogramSample {}
);

impl SRElectrocardiogramSample {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        /// Date of the start of the batch of ECG data
        #[unsafe(method(date))]
        #[unsafe(method_family = none)]
        pub unsafe fn date(&self) -> Retained<NSDate>;

        /// Frequency in hertz at which the ECG data was recorded
        #[unsafe(method(frequency))]
        #[unsafe(method_family = none)]
        pub unsafe fn frequency(&self) -> Retained<NSMeasurement<NSUnitFrequency>>;

        /// The session to which this sample belongs
        #[unsafe(method(session))]
        #[unsafe(method_family = none)]
        pub unsafe fn session(&self) -> Retained<SRElectrocardiogramSession>;

        #[unsafe(method(lead))]
        #[unsafe(method_family = none)]
        pub unsafe fn lead(&self) -> SRElectrocardiogramLead;

        #[unsafe(method(data))]
        #[unsafe(method_family = none)]
        pub unsafe fn data(&self) -> Retained<NSArray<SRElectrocardiogramData>>;
    );
}

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphotoplethysmogramopticalsamplecondition?language=objc)
// NS_TYPED_ENUM
pub type SRPhotoplethysmogramOpticalSampleCondition = NSString;

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphotoplethysmogramopticalsampleconditionsignalsaturation?language=objc)
    pub static SRPhotoplethysmogramOpticalSampleConditionSignalSaturation:
        &'static SRPhotoplethysmogramOpticalSampleCondition;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphotoplethysmogramopticalsampleconditionunreliablenoise?language=objc)
    pub static SRPhotoplethysmogramOpticalSampleConditionUnreliableNoise:
        &'static SRPhotoplethysmogramOpticalSampleCondition;
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphotoplethysmogramopticalsample?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRPhotoplethysmogramOpticalSample;
);

unsafe impl Send for SRPhotoplethysmogramOpticalSample {}

unsafe impl Sync for SRPhotoplethysmogramOpticalSample {}

extern_conformance!(
    unsafe impl NSCoding for SRPhotoplethysmogramOpticalSample {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRPhotoplethysmogramOpticalSample {}
);

impl SRPhotoplethysmogramOpticalSample {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        /// The index of the LED in use during the sample reading
        #[unsafe(method(emitter))]
        #[unsafe(method_family = none)]
        pub unsafe fn emitter(&self) -> NSInteger;

        /// The set of photodiodes in use during the sample reading
        #[unsafe(method(activePhotodiodeIndexes))]
        #[unsafe(method_family = none)]
        pub unsafe fn activePhotodiodeIndexes(&self) -> Retained<NSIndexSet>;

        /// identifier to distinguish between different signals produced
        /// using the same photodiodes and emitters
        ///
        ///
        /// To provide the same quality of service certain system conditions may require configuring the
        /// PPG sensor behavior differently while using the same photodiodes and emitters. This
        /// identifier can be used distinguish between the different signals generated by these
        /// different configurations.
        #[unsafe(method(signalIdentifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn signalIdentifier(&self) -> NSInteger;

        /// the wavelength in nanometers the emitter was designed to produce while
        /// operating at a specific temperature
        #[unsafe(method(nominalWavelength))]
        #[unsafe(method_family = none)]
        pub unsafe fn nominalWavelength(&self) -> Retained<NSMeasurement<NSUnitLength>>;

        /// a temperature compensated wavelength in nanometers estimate that the emitter is producing
        #[unsafe(method(effectiveWavelength))]
        #[unsafe(method_family = none)]
        pub unsafe fn effectiveWavelength(&self) -> Retained<NSMeasurement<NSUnitLength>>;

        /// Sampling frequency of PPG data in Hz
        #[unsafe(method(samplingFrequency))]
        #[unsafe(method_family = none)]
        pub unsafe fn samplingFrequency(&self) -> Retained<NSMeasurement<NSUnitFrequency>>;

        /// nanoseconds since the
        /// `SRPhotoplethysmogramSample`start date of the
        /// specific optical sample
        #[unsafe(method(nanosecondsSinceStart))]
        #[unsafe(method_family = none)]
        pub unsafe fn nanosecondsSinceStart(&self) -> i64;

        /// The PPG waveform
        ///
        ///
        /// This may be
        /// `nil`when the sensor data reading is invalid
        #[unsafe(method(normalizedReflectance))]
        #[unsafe(method_family = none)]
        pub unsafe fn normalizedReflectance(&self) -> Option<Retained<NSNumber>>;

        /// White noise estimation
        ///
        ///
        /// This may be
        /// `nil`when the sensor data reading is invalid
        #[unsafe(method(whiteNoise))]
        #[unsafe(method_family = none)]
        pub unsafe fn whiteNoise(&self) -> Option<Retained<NSNumber>>;

        /// Pink noise estimation
        ///
        ///
        /// This may be
        /// `nil`when the sensor data reading is invalid
        #[unsafe(method(pinkNoise))]
        #[unsafe(method_family = none)]
        pub unsafe fn pinkNoise(&self) -> Option<Retained<NSNumber>>;

        /// Estimated ambient noise intrusion
        ///
        ///
        /// This may be
        /// `nil`when the sensor data reading is invalid
        #[unsafe(method(backgroundNoise))]
        #[unsafe(method_family = none)]
        pub unsafe fn backgroundNoise(&self) -> Option<Retained<NSNumber>>;

        /// Estimated electronics noise floor level of the sensor
        ///
        ///
        /// To estimate the total ambient noise, subtract scaled background noise offset
        /// from the background noise. The scaling factor can be computed based on
        /// the researcher's digital filter setup.
        /// This may be
        /// `nil`when the sensor data reading is invalid
        #[unsafe(method(backgroundNoiseOffset))]
        #[unsafe(method_family = none)]
        pub unsafe fn backgroundNoiseOffset(&self) -> Option<Retained<NSNumber>>;

        /// Flags indicating sensor context or conditions that may effect
        /// the sample reading
        ///
        ///
        /// These flags can provide some indication of data validity or other system conditions
        /// that may influence how the recorded data should be treated.
        #[unsafe(method(conditions))]
        #[unsafe(method_family = none)]
        pub unsafe fn conditions(
            &self,
        ) -> Retained<NSArray<SRPhotoplethysmogramOpticalSampleCondition>>;
    );
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphotoplethysmogramaccelerometersample?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRPhotoplethysmogramAccelerometerSample;
);

unsafe impl Send for SRPhotoplethysmogramAccelerometerSample {}

unsafe impl Sync for SRPhotoplethysmogramAccelerometerSample {}

extern_conformance!(
    unsafe impl NSCoding for SRPhotoplethysmogramAccelerometerSample {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRPhotoplethysmogramAccelerometerSample {}
);

impl SRPhotoplethysmogramAccelerometerSample {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        /// nanoseconds since the
        /// `SRPhotoplethysmogramSample`start date of the specific
        /// accelerometer sample
        #[unsafe(method(nanosecondsSinceStart))]
        #[unsafe(method_family = none)]
        pub unsafe fn nanosecondsSinceStart(&self) -> i64;

        /// Sampling frequency of accelerometer data in Hz
        #[unsafe(method(samplingFrequency))]
        #[unsafe(method_family = none)]
        pub unsafe fn samplingFrequency(&self) -> Retained<NSMeasurement<NSUnitFrequency>>;

        /// X-axis acceleration in G's
        #[unsafe(method(x))]
        #[unsafe(method_family = none)]
        pub unsafe fn x(&self) -> Retained<NSMeasurement<NSUnitAcceleration>>;

        /// Y-axis acceleration in G's
        #[unsafe(method(y))]
        #[unsafe(method_family = none)]
        pub unsafe fn y(&self) -> Retained<NSMeasurement<NSUnitAcceleration>>;

        /// Z-axis acceleration in G's
        #[unsafe(method(z))]
        #[unsafe(method_family = none)]
        pub unsafe fn z(&self) -> Retained<NSMeasurement<NSUnitAcceleration>>;
    );
}

/// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphotoplethysmogramsampleusage?language=objc)
// NS_TYPED_ENUM
pub type SRPhotoplethysmogramSampleUsage = NSString;

extern "C" {
    /// A heart rate reading actively taken by a user in an app context
    ///
    ///
    /// Typically driven by the user using the HeartRate app or a workout session.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphotoplethysmogramsampleusageforegroundheartrate?language=objc)
    pub static SRPhotoplethysmogramSampleUsageForegroundHeartRate:
        &'static SRPhotoplethysmogramSampleUsage;
}

extern "C" {
    /// A sensor reading actively taken by a user in a deep breathing context
    ///
    ///
    /// Typically driven by the user performing a reflect or breathe session
    /// in the Mindfulness app.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphotoplethysmogramsampleusagedeepbreathing?language=objc)
    pub static SRPhotoplethysmogramSampleUsageDeepBreathing:
        &'static SRPhotoplethysmogramSampleUsage;
}

extern "C" {
    /// A blood oxygen reading actively taken by a user in app context
    ///
    ///
    /// Typically driven by the user using the BloodOxygen app
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphotoplethysmogramsampleusageforegroundbloodoxygen?language=objc)
    pub static SRPhotoplethysmogramSampleUsageForegroundBloodOxygen:
        &'static SRPhotoplethysmogramSampleUsage;
}

extern "C" {
    /// A sample reading passively taken by the system
    ///
    ///
    /// These are driven by the system to perform the various heart features of watchOS
    /// (e.g., background blood oxygen, afib notifications, low cardio notifications, etc)
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphotoplethysmogramsampleusagebackgroundsystem?language=objc)
    pub static SRPhotoplethysmogramSampleUsageBackgroundSystem:
        &'static SRPhotoplethysmogramSampleUsage;
}

extern_class!(
    /// [Apple's documentation](https://developer.apple.com/documentation/sensorkit/srphotoplethysmogramsample?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct SRPhotoplethysmogramSample;
);

unsafe impl Send for SRPhotoplethysmogramSample {}

unsafe impl Sync for SRPhotoplethysmogramSample {}

extern_conformance!(
    unsafe impl NSCoding for SRPhotoplethysmogramSample {}
);

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

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

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

extern_conformance!(
    unsafe impl NSSecureCoding for SRPhotoplethysmogramSample {}
);

impl SRPhotoplethysmogramSample {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

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

        /// the start date of a data collection session
        #[unsafe(method(startDate))]
        #[unsafe(method_family = none)]
        pub unsafe fn startDate(&self) -> Retained<NSDate>;

        /// nanoseconds since the start date of this specific sample
        #[unsafe(method(nanosecondsSinceStart))]
        #[unsafe(method_family = none)]
        pub unsafe fn nanosecondsSinceStart(&self) -> i64;

        /// How the sensor was being used during the sample reading
        ///
        ///
        /// It is possible for these to occur in combination
        #[unsafe(method(usage))]
        #[unsafe(method_family = none)]
        pub unsafe fn usage(&self) -> Retained<NSArray<SRPhotoplethysmogramSampleUsage>>;

        #[unsafe(method(opticalSamples))]
        #[unsafe(method_family = none)]
        pub unsafe fn opticalSamples(&self)
            -> Retained<NSArray<SRPhotoplethysmogramOpticalSample>>;

        #[unsafe(method(accelerometerSamples))]
        #[unsafe(method_family = none)]
        pub unsafe fn accelerometerSamples(
            &self,
        ) -> Retained<NSArray<SRPhotoplethysmogramAccelerometerSample>>;

        /// temperature of the PPG sensors in the watch, measured in celsius
        ///
        ///
        /// This may be
        /// `nil`when the sensor data reading is invalid or if is not supported by the hardware
        #[unsafe(method(temperature))]
        #[unsafe(method_family = none)]
        pub unsafe fn temperature(&self) -> Option<Retained<NSMeasurement<NSUnitTemperature>>>;
    );
}