objc2_health_kit/generated/

HKQuery.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
use objc2::__framework_prelude::*;
use objc2_foundation::*;

use crate::*;

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

unsafe impl Send for HKQuery {}

unsafe impl Sync for HKQuery {}

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

impl HKQuery {
    extern_methods!(
        #[cfg(feature = "HKObjectType")]
        #[unsafe(method(objectType))]
        #[unsafe(method_family = none)]
        pub unsafe fn objectType(&self) -> Option<Retained<HKObjectType>>;

        #[cfg(feature = "HKObjectType")]
        #[deprecated]
        #[unsafe(method(sampleType))]
        #[unsafe(method_family = none)]
        pub unsafe fn sampleType(&self) -> Option<Retained<HKSampleType>>;

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

        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl HKQuery {
    extern_methods!(
        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

/// Time interval options are used to describe how an HKSample's time period overlaps with a given time period.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/healthkit/hkqueryoptions?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct HKQueryOptions(pub NSUInteger);
bitflags::bitflags! {
    impl HKQueryOptions: NSUInteger {
        #[doc(alias = "HKQueryOptionNone")]
        const None = 0;
        #[doc(alias = "HKQueryOptionStrictStartDate")]
        const StrictStartDate = 1<<0;
        #[doc(alias = "HKQueryOptionStrictEndDate")]
        const StrictEndDate = 1<<1;
    }
}

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

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

/// HKObjectPredicates.
impl HKQuery {
    extern_methods!(
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches objects with metadata that contains a given key.
        ///
        ///
        /// Parameter `key`: The metadata key.
        #[unsafe(method(predicateForObjectsWithMetadataKey:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsWithMetadataKey(key: &NSString) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses
        ///
        /// Creates a query predicate that matches objects with metadata containing a value the matches one of the
        /// given values for the given key.
        ///
        ///
        /// Parameter `key`: The metadata key.
        ///
        /// Parameter `allowedValues`: The list of values that the metadata value can be equal to.
        ///
        /// # Safety
        ///
        /// `allowed_values` generic should be of the correct type.
        #[unsafe(method(predicateForObjectsWithMetadataKey:allowedValues:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsWithMetadataKey_allowedValues(
            key: &NSString,
            allowed_values: &NSArray,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses
        ///
        /// Creates a query predicate that matches objects with a value for a given metadata key matches the given
        /// operator type and value.
        ///
        ///
        /// Parameter `key`: The metadata key.
        ///
        /// Parameter `operatorType`: The comparison operator type for the expression.
        ///
        /// Parameter `value`: The value to be compared against.
        ///
        /// # Safety
        ///
        /// `value` should be of the correct type.
        #[unsafe(method(predicateForObjectsWithMetadataKey:operatorType:value:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsWithMetadataKey_operatorType_value(
            key: &NSString,
            operator_type: NSPredicateOperatorType,
            value: &AnyObject,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKSource")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches objects saved by a given source.
        ///
        ///
        /// Parameter `source`: The source.
        #[unsafe(method(predicateForObjectsFromSource:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsFromSource(source: &HKSource) -> Retained<NSPredicate>;

        #[cfg(feature = "HKSource")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches objects saved by any of the given sources.
        ///
        ///
        /// Parameter `sources`: The list of sources.
        #[unsafe(method(predicateForObjectsFromSources:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsFromSources(
            sources: &NSSet<HKSource>,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKSourceRevision")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches objects saved by any of the specified HKSourceRevisions.
        ///
        ///
        /// Parameter `sourceRevisions`: The list of source revisions.
        #[unsafe(method(predicateForObjectsFromSourceRevisions:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsFromSourceRevisions(
            source_revisions: &NSSet<HKSourceRevision>,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKDevice")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches objects associated with any of the given devices. All properties
        /// of each HKDevice are considered in the query and must match exactly, including nil values. To perform
        /// searches based on specific device properties, use predicateForObjectsWithDeviceProperty:allowedValues:.
        ///
        ///
        /// Parameter `devices`: The set of devices that generated data.
        #[unsafe(method(predicateForObjectsFromDevices:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsFromDevices(
            devices: &NSSet<HKDevice>,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches objects associated with an HKDevice with the specified device
        /// property matching any value included in allowedValues. To query for samples with devices that match all
        /// the properties of an HKDevice, use predicateForObjectsFromDevices.
        ///
        ///
        /// Parameter `key`: The device property key. (See HKDevice.h)
        ///
        /// Parameter `allowedValues`: The set of values for which the device property can match. An empty set will match all
        /// devices whose property value is nil.
        #[unsafe(method(predicateForObjectsWithDeviceProperty:allowedValues:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsWithDeviceProperty_allowedValues(
            key: &NSString,
            allowed_values: &NSSet<NSString>,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches the object saved with a particular UUID.
        ///
        ///
        /// Parameter `UUID`: The UUID of the object.
        #[unsafe(method(predicateForObjectWithUUID:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectWithUUID(uuid: &NSUUID) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches the objects saved with one of the given UUIDs.
        ///
        ///
        /// Parameter `UUIDs`: The set of NSUUIDs.
        #[unsafe(method(predicateForObjectsWithUUIDs:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsWithUUIDs(uui_ds: &NSSet<NSUUID>)
            -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches the objects that are not associated with an HKCorrelation.
        #[unsafe(method(predicateForObjectsWithNoCorrelation))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsWithNoCorrelation() -> Retained<NSPredicate>;

        #[cfg(all(feature = "HKObject", feature = "HKSample", feature = "HKWorkout"))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches the objects that have been added to the given workout.
        ///
        ///
        /// Parameter `workout`: The HKWorkout that the object was added to.
        #[unsafe(method(predicateForObjectsFromWorkout:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsFromWorkout(workout: &HKWorkout) -> Retained<NSPredicate>;

        #[cfg(all(
            feature = "HKElectrocardiogram",
            feature = "HKObject",
            feature = "HKSample"
        ))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches the objects that have been added to the given electrocardiogram
        ///
        ///
        /// Parameter `electrocardiogram`: The HKElectrocardiogram that the object was added to.
        #[unsafe(method(predicateForObjectsAssociatedWithElectrocardiogram:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForObjectsAssociatedWithElectrocardiogram(
            electrocardiogram: &HKElectrocardiogram,
        ) -> Retained<NSPredicate>;

        #[cfg(all(
            feature = "HKObject",
            feature = "HKSample",
            feature = "HKWorkout",
            feature = "HKWorkoutActivity"
        ))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches Workout Effort samples that have been related to the given workout
        ///
        ///
        /// Parameter `workout`: The HKWorkout that the object is related to.
        ///
        /// Parameter `activity`: The HKWorkoutActivity that the object is related to.
        #[unsafe(method(predicateForWorkoutEffortSamplesRelatedToWorkout:activity:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutEffortSamplesRelatedToWorkout_activity(
            workout: &HKWorkout,
            activity: Option<&HKWorkoutActivity>,
        ) -> Retained<NSPredicate>;
    );
}

/// HKSamplePredicates.
impl HKQuery {
    extern_methods!(
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches samples with a startDate and an endDate that lie inside of a
        /// given time interval.
        ///
        ///
        /// Parameter `startDate`: The start date of the predicate's time interval.
        ///
        /// Parameter `endDate`: The end date of the predicate's time interval.
        ///
        /// Parameter `options`: The rules for how a sample's time interval overlaps with the predicate's time interval.
        #[unsafe(method(predicateForSamplesWithStartDate:endDate:options:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForSamplesWithStartDate_endDate_options(
            start_date: Option<&NSDate>,
            end_date: Option<&NSDate>,
            options: HKQueryOptions,
        ) -> Retained<NSPredicate>;
    );
}

/// HKQuantitySamplePredicates.
impl HKQuery {
    extern_methods!(
        #[cfg(feature = "HKQuantity")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches quantity samples with values that match the expression formed by
        /// the given operator and quantity.
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `quantity`: The quantity that the sample's quantity is being compared to. It is the right hand side
        /// of the expression.
        #[unsafe(method(predicateForQuantitySamplesWithOperatorType:quantity:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForQuantitySamplesWithOperatorType_quantity(
            operator_type: NSPredicateOperatorType,
            quantity: &HKQuantity,
        ) -> Retained<NSPredicate>;
    );
}

/// HKCategorySamplePredicates.
impl HKQuery {
    extern_methods!(
        #[unsafe(method(predicateForCategorySamplesWithOperatorType:value:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForCategorySamplesWithOperatorType_value(
            operator_type: NSPredicateOperatorType,
            value: NSInteger,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches all specified category values.
        #[unsafe(method(predicateForCategorySamplesEqualToValues:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForCategorySamplesEqualToValues(
            values: &NSSet<NSNumber>,
        ) -> Retained<NSPredicate>;
    );
}

/// HKWorkoutPredicates.
impl HKQuery {
    extern_methods!(
        #[cfg(feature = "HKWorkout")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkouts with the given HKWorkoutActivityType.
        ///
        ///
        /// Parameter `workoutActivityType`: The HKWorkoutActivity type of the workout
        #[unsafe(method(predicateForWorkoutsWithWorkoutActivityType:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutsWithWorkoutActivityType(
            workout_activity_type: HKWorkoutActivityType,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkouts by the given operator type and duration
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `duration`: The value that the workout's duration is being compared to. It is the right hand side of the
        /// expression.
        #[unsafe(method(predicateForWorkoutsWithOperatorType:duration:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutsWithOperatorType_duration(
            operator_type: NSPredicateOperatorType,
            duration: NSTimeInterval,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKQuantity")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkouts by the given operator type and totalEnergyBurned
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `totalEnergyBurned`: The value that the workout's totalEnergyBurned is being compared to. It is the right hand side of the
        /// expression. The unit for this value should be of type Energy.
        #[deprecated = "Use predicateForWorkoutsWithOperatorType:quantityType:sumQuantity: passing the HKQuantityType for HKQuantityTypeIdentifierActiveEnergyBurned"]
        #[unsafe(method(predicateForWorkoutsWithOperatorType:totalEnergyBurned:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutsWithOperatorType_totalEnergyBurned(
            operator_type: NSPredicateOperatorType,
            total_energy_burned: &HKQuantity,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKQuantity")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkouts by the given operator type and totalEnergyBurned
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `totalDistance`: The value that the workout's totalEnergyBurned is being compared to. It is the right hand side of the
        /// expression. The unit for this value should be of type Distance.
        #[deprecated = "Use predicateForWorkoutsWithOperatorType:quantityType:sumQuantity: passing the HKQuantityType for the desired distance type"]
        #[unsafe(method(predicateForWorkoutsWithOperatorType:totalDistance:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutsWithOperatorType_totalDistance(
            operator_type: NSPredicateOperatorType,
            total_distance: &HKQuantity,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKQuantity")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkouts by the given operator type and totalSwimmingStrokeCount
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `totalSwimmingStrokeCount`: The value that the workout's totalSwimmingStrokeCount is being compared to.
        /// It is the right hand side of the expression. The unit for this value should
        /// be of type Count.
        #[deprecated = "Use predicateForWorkoutsWithOperatorType:quantityType:sumQuantity: passing the HKQuantityType for HKQuantityTypeIdentifierSwimmingStrokeCount"]
        #[unsafe(method(predicateForWorkoutsWithOperatorType:totalSwimmingStrokeCount:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutsWithOperatorType_totalSwimmingStrokeCount(
            operator_type: NSPredicateOperatorType,
            total_swimming_stroke_count: &HKQuantity,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKQuantity")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkouts by the given operator type and totalFlightsClimbed
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `totalFlightsClimbed`: The value that the workout's totalFlightsClimbed is being compared to.
        /// It is the right hand side of the expression. The unit for this value should
        /// be of type Count.
        #[deprecated = "Use predicateForWorkoutsWithOperatorType:quantityType:sumQuantity: passing the HKQuantityType for HKQuantityTypeIdentifierFlightsClimbed"]
        #[unsafe(method(predicateForWorkoutsWithOperatorType:totalFlightsClimbed:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutsWithOperatorType_totalFlightsClimbed(
            operator_type: NSPredicateOperatorType,
            total_flights_climbed: &HKQuantity,
        ) -> Retained<NSPredicate>;

        #[cfg(all(feature = "HKObjectType", feature = "HKQuantity"))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkouts by the given operator type and sumQuantity in the statistics for
        /// the specified type.
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `quantityType`: The quantity type to compare statistics for. Should be a cumulative quantity type.
        ///
        /// Parameter `sumQuantity`: The sum value that the workout statistics are being compared to. The unit for this value should
        /// match the allowed values for the quantityType.
        #[unsafe(method(predicateForWorkoutsWithOperatorType:quantityType:sumQuantity:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutsWithOperatorType_quantityType_sumQuantity(
            operator_type: NSPredicateOperatorType,
            quantity_type: &HKQuantityType,
            sum_quantity: &HKQuantity,
        ) -> Retained<NSPredicate>;

        #[cfg(all(feature = "HKObjectType", feature = "HKQuantity"))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkouts by the given operator type and minimumQuantity in the statistics
        /// for the specified type.
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `quantityType`: The quantity type to compare statistics for. Should be a discrete quantity type.
        ///
        /// Parameter `minimumQuantity`: The minumum value that the workout statistics are being compared to. The unit for this value should
        /// match the allowed values for the quantityType.
        #[unsafe(method(predicateForWorkoutsWithOperatorType:quantityType:minimumQuantity:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutsWithOperatorType_quantityType_minimumQuantity(
            operator_type: NSPredicateOperatorType,
            quantity_type: &HKQuantityType,
            minimum_quantity: &HKQuantity,
        ) -> Retained<NSPredicate>;

        #[cfg(all(feature = "HKObjectType", feature = "HKQuantity"))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkouts by the given operator type and maximumQuantity in the statistics
        /// for the specified type.
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `quantityType`: The quantity type to compare statistics for. Should be a discrete quantity type.
        ///
        /// Parameter `maximumQuantity`: The maximum value that the workout statistics are being compared to. The unit for this value should
        /// match the allowed values for the quantityType.
        #[unsafe(method(predicateForWorkoutsWithOperatorType:quantityType:maximumQuantity:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutsWithOperatorType_quantityType_maximumQuantity(
            operator_type: NSPredicateOperatorType,
            quantity_type: &HKQuantityType,
            maximum_quantity: &HKQuantity,
        ) -> Retained<NSPredicate>;

        #[cfg(all(feature = "HKObjectType", feature = "HKQuantity"))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkouts by the given operator type and averageQuantity in the statistics
        /// for the specified type.
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `quantityType`: The quantity type to compare statistics for. Should be a discrete quantity type.
        ///
        /// Parameter `averageQuantity`: The average value that the workout statistics are being compared to. The unit for this value should
        /// match the allowed values for the quantityType.
        #[unsafe(method(predicateForWorkoutsWithOperatorType:quantityType:averageQuantity:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutsWithOperatorType_quantityType_averageQuantity(
            operator_type: NSPredicateOperatorType,
            quantity_type: &HKQuantityType,
            average_quantity: &HKQuantity,
        ) -> Retained<NSPredicate>;
    );
}

/// HKWorkoutActivityPredicates.
impl HKQuery {
    extern_methods!(
        #[cfg(feature = "HKWorkout")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkoutActivity objects with the given HKWorkoutActivityType.
        /// The resulting predicate should be wrapped using predicateForWorkoutsWithActivityPredicate: before being used in a query.
        ///
        ///
        /// Parameter `workoutActivityType`: The HKWorkoutActivity type of the workout
        #[unsafe(method(predicateForWorkoutActivitiesWithWorkoutActivityType:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutActivitiesWithWorkoutActivityType(
            workout_activity_type: HKWorkoutActivityType,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkoutActivity objects by the given operator type and duration.
        /// The resulting predicate should be wrapped using predicateForWorkoutsWithActivityPredicate: before being used in a query.
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `duration`: The value that the workout's duration is being compared to. It is the right hand side of the
        /// expression.
        #[unsafe(method(predicateForWorkoutActivitiesWithOperatorType:duration:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutActivitiesWithOperatorType_duration(
            operator_type: NSPredicateOperatorType,
            duration: NSTimeInterval,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkoutActivity objects with a startDate and an endDate that lie inside of a
        /// given time interval. The resulting predicate should be wrapped using predicateForWorkoutsWithActivityPredicate:
        /// before being used in a query.
        ///
        ///
        /// Parameter `startDate`: The start date of the predicate's time interval.
        ///
        /// Parameter `endDate`: The end date of the predicate's time interval.
        ///
        /// Parameter `options`: The rules for how a activity's time interval overlaps with the predicate's time interval.
        #[unsafe(method(predicateForWorkoutActivitiesWithStartDate:endDate:options:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutActivitiesWithStartDate_endDate_options(
            start_date: Option<&NSDate>,
            end_date: Option<&NSDate>,
            options: HKQueryOptions,
        ) -> Retained<NSPredicate>;

        #[cfg(all(feature = "HKObjectType", feature = "HKQuantity"))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkoutActivity objetcs by the given operator type and sumQuantity in the
        /// statistics for the specified type. The resulting predicate should be wrapped using predicateForWorkoutsWithActivityPredicate:
        /// before being used in a query.
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `quantityType`: The quantity type to compare statistics for. Should be a cumulative quantity type.
        ///
        /// Parameter `sumQuantity`: The sum value that the activity statistics are being compared to. The unit for this value should
        /// match the allowed values for the quantityType.
        #[unsafe(method(predicateForWorkoutActivitiesWithOperatorType:quantityType:sumQuantity:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutActivitiesWithOperatorType_quantityType_sumQuantity(
            operator_type: NSPredicateOperatorType,
            quantity_type: &HKQuantityType,
            sum_quantity: &HKQuantity,
        ) -> Retained<NSPredicate>;

        #[cfg(all(feature = "HKObjectType", feature = "HKQuantity"))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkoutActivity objetcs  by the given operator type and minimumQuantity in the
        /// statistics for the specified type. The resulting predicate should be wrapped using predicateForWorkoutsWithActivityPredicate:
        /// before being used in a query.
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `quantityType`: The quantity type to compare statistics for. Should be a discrete quantity type.
        ///
        /// Parameter `minimumQuantity`: The minumum value that the activty statistics are being compared to. The unit for this value should
        /// match the allowed values for the quantityType.
        #[unsafe(method(predicateForWorkoutActivitiesWithOperatorType:quantityType:minimumQuantity:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutActivitiesWithOperatorType_quantityType_minimumQuantity(
            operator_type: NSPredicateOperatorType,
            quantity_type: &HKQuantityType,
            minimum_quantity: &HKQuantity,
        ) -> Retained<NSPredicate>;

        #[cfg(all(feature = "HKObjectType", feature = "HKQuantity"))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkoutActivity objetcs by the given operator type and maximumQuantity in the
        /// statistics for the specified type. The resulting predicate should be wrapped using predicateForWorkoutsWithActivityPredicate:
        /// before being used in a query.
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `quantityType`: The quantity type to compare statistics for. Should be a discrete quantity type.
        ///
        /// Parameter `maximumQuantity`: The maximum value that the activity statistics are being compared to. The unit for this value should
        /// match the allowed values for the quantityType.
        #[unsafe(method(predicateForWorkoutActivitiesWithOperatorType:quantityType:maximumQuantity:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutActivitiesWithOperatorType_quantityType_maximumQuantity(
            operator_type: NSPredicateOperatorType,
            quantity_type: &HKQuantityType,
            maximum_quantity: &HKQuantity,
        ) -> Retained<NSPredicate>;

        #[cfg(all(feature = "HKObjectType", feature = "HKQuantity"))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKWorkoutActivity objetcs by the given operator type and averageQuantity in the
        /// statistics for the specified type. The resulting predicate should be wrapped using predicateForWorkoutsWithActivityPredicate:
        /// before being used in a query.
        ///
        ///
        /// Parameter `operatorType`: The operator type for the expression.
        ///
        /// Parameter `quantityType`: The quantity type to compare statistics for. Should be a discrete quantity type.
        ///
        /// Parameter `averageQuantity`: The average value that the activity statistics are being compared to. The unit for this value should
        /// match the allowed values for the quantityType.
        #[unsafe(method(predicateForWorkoutActivitiesWithOperatorType:quantityType:averageQuantity:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutActivitiesWithOperatorType_quantityType_averageQuantity(
            operator_type: NSPredicateOperatorType,
            quantity_type: &HKQuantityType,
            average_quantity: &HKQuantity,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches workouts containing an activity matching the passed predicate.
        ///
        ///
        /// Parameter `activityPredicate`: The predicate on the activities of the workout
        #[unsafe(method(predicateForWorkoutsWithActivityPredicate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForWorkoutsWithActivityPredicate(
            activity_predicate: &NSPredicate,
        ) -> Retained<NSPredicate>;
    );
}

/// HKActivitySummaryPredicates.
impl HKQuery {
    extern_methods!(
        /// Creates a predicate for use with HKActivitySummaryQuery
        ///
        /// Creates a query predicate that matches HKActivitySummaries with the given date components.
        ///
        ///
        /// Parameter `dateComponents`: The date components of the activity summary. These date components should contain era, year, month,
        /// and day components in the gregorian calendar.
        #[unsafe(method(predicateForActivitySummaryWithDateComponents:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForActivitySummaryWithDateComponents(
            date_components: &NSDateComponents,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKActivitySummaryQuery
        ///
        /// Creates a query predicate that matches HKActivitySummaries that fall between the given date components.
        ///
        ///
        /// Parameter `startDateComponents`: The date components that define the beginning of the range. These date components should contain
        /// era, year, month, and day components in the gregorian calendar.
        ///
        ///
        /// Parameter `endDateComponents`: The date components that define the end of the range. These date components should contain era,
        /// year, month, and day components in the gregorian calendar.
        #[unsafe(method(predicateForActivitySummariesBetweenStartDateComponents:endDateComponents:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForActivitySummariesBetweenStartDateComponents_endDateComponents(
            start_date_components: &NSDateComponents,
            end_date_components: &NSDateComponents,
        ) -> Retained<NSPredicate>;
    );
}

/// HKClinicalRecordPredicates.
impl HKQuery {
    extern_methods!(
        #[cfg(feature = "HKFHIRResource")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKClinicalRecords with a specific FHIR resource type.
        ///
        ///
        /// Parameter `resourceType`: The FHIR resource type.
        #[unsafe(method(predicateForClinicalRecordsWithFHIRResourceType:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForClinicalRecordsWithFHIRResourceType(
            resource_type: &HKFHIRResourceType,
        ) -> Retained<NSPredicate>;

        #[cfg(all(feature = "HKFHIRResource", feature = "HKSource"))]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKClinicalRecords for a given source, FHIR resource type, and FHIR identifier.
        ///
        ///
        /// Parameter `source`: The source.
        ///
        /// Parameter `resourceType`: The FHIR resource type.
        ///
        /// Parameter `identifier`: The FHIR identifier.
        #[unsafe(method(predicateForClinicalRecordsFromSource:FHIRResourceType:identifier:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForClinicalRecordsFromSource_FHIRResourceType_identifier(
            source: &HKSource,
            resource_type: &HKFHIRResourceType,
            identifier: &NSString,
        ) -> Retained<NSPredicate>;
    );
}

/// HKElectrocardiogramPredicates.
impl HKQuery {
    extern_methods!(
        #[cfg(feature = "HKElectrocardiogram")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKElectrocardiograms with a specific classification.
        ///
        ///
        /// Parameter `classification`: The classification for the electrocardiogram.
        #[unsafe(method(predicateForElectrocardiogramsWithClassification:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForElectrocardiogramsWithClassification(
            classification: HKElectrocardiogramClassification,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKElectrocardiogram")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKElectrocardiograms with a specificied symptoms status.
        ///
        ///
        /// Parameter `symptomsStatus`: The symptoms status for the electrocardiogram.
        #[unsafe(method(predicateForElectrocardiogramsWithSymptomsStatus:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForElectrocardiogramsWithSymptomsStatus(
            symptoms_status: HKElectrocardiogramSymptomsStatus,
        ) -> Retained<NSPredicate>;
    );
}

/// HKVerifiableClinicalRecordPredicates.
impl HKQuery {
    extern_methods!(
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a predicate that matches HKVerifiableClinicalRecords with a relevant date within a date interval.
        ///
        ///
        /// Parameter `dateInterval`: The date interval that the record's relevant date is in.
        #[unsafe(method(predicateForVerifiableClinicalRecordsWithRelevantDateWithinDateInterval:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForVerifiableClinicalRecordsWithRelevantDateWithinDateInterval(
            date_interval: &NSDateInterval,
        ) -> Retained<NSPredicate>;
    );
}

/// HKStateOfMind.
impl HKQuery {
    extern_methods!(
        /// Creates a predicate for use with HKStateOfMind
        ///
        /// Creates a query predicate that matches HKStateOfMind samples that have a valence property matching the operator type and valence.
        ///
        ///
        /// Parameter `valence`: The value to be compared against.
        ///
        /// Parameter `operatorType`: The comparison operator type for the expression.
        #[unsafe(method(predicateForStatesOfMindWithValence:operatorType:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForStatesOfMindWithValence_operatorType(
            valence: c_double,
            operator_type: NSPredicateOperatorType,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKStateOfMind")]
        /// Creates a predicate for use with HKStateOfMind
        ///
        /// Creates a query predicate that matches HKStateOfMind samples that have the specified kind of feeling type.
        ///
        ///
        /// Parameter `kind`: The kind of feeling type to be compared against.
        #[unsafe(method(predicateForStatesOfMindWithKind:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForStatesOfMindWithKind(
            kind: HKStateOfMindKind,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKStateOfMind")]
        /// Creates a predicate for use with HKStateOfMind
        ///
        /// Creates a query predicate that matches HKStateOfMind samples that have the specified label.
        ///
        ///
        /// Parameter `label`: The label to be compared against.
        #[unsafe(method(predicateForStatesOfMindWithLabel:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForStatesOfMindWithLabel(
            label: HKStateOfMindLabel,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKStateOfMind")]
        /// Creates a predicate for use with HKStateOfMind
        ///
        /// Creates a query predicate that matches HKStateOfMind samples that have the specified association.
        ///
        ///
        /// Parameter `association`: The association to be compared against.
        #[unsafe(method(predicateForStatesOfMindWithAssociation:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForStatesOfMindWithAssociation(
            association: HKStateOfMindAssociation,
        ) -> Retained<NSPredicate>;
    );
}

/// HKMedicationDoseEvent.
impl HKQuery {
    extern_methods!(
        #[cfg(feature = "HKMedicationDoseEvent")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKMedicationDoseEvent samples that have the status specified.
        ///
        ///
        /// Parameter `status`: The logged status of the medication dose event to match.
        #[unsafe(method(predicateForMedicationDoseEventWithStatus:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForMedicationDoseEventWithStatus(
            status: HKMedicationDoseEventLogStatus,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKMedicationDoseEvent samples that have any of the statuses specified.
        ///
        ///
        /// Parameter `statuses`: The logged statuses of the medication dose event to match.
        #[unsafe(method(predicateForMedicationDoseEventWithStatuses:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForMedicationDoseEventWithStatuses(
            statuses: &NSSet<NSNumber>,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKMedicationDoseEvent samples that have the exact scheduled date specified.
        ///
        ///
        /// Parameter `scheduledDate`: The exact scheduled date of the medication dose event to match.
        #[unsafe(method(predicateForMedicationDoseEventWithScheduledDate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForMedicationDoseEventWithScheduledDate(
            scheduled_date: &NSDate,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKMedicationDoseEvent samples that have any of the exact scheduled dates specified.
        ///
        ///
        /// Parameter `scheduledDates`: The exact scheduled dates of any medication dose event to match.
        #[unsafe(method(predicateForMedicationDoseEventWithScheduledDates:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForMedicationDoseEventWithScheduledDates(
            scheduled_dates: &NSSet<NSDate>,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKMedicationDoseEvent samples that have a scheduled date within a window of scheduled times. If nil is provided to either parameter, the respective side of the window is unbound.
        ///
        ///
        /// Parameter `startDate`: The beginning of the window for scheduled dates of any medication dose event to match.
        ///
        /// Parameter `endDate`: The beginning of the window for scheduled dates of any medication dose event to match.
        #[unsafe(method(predicateForMedicationDoseEventWithScheduledStartDate:endDate:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForMedicationDoseEventWithScheduledStartDate_endDate(
            start_date: Option<&NSDate>,
            end_date: Option<&NSDate>,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKHealthConceptIdentifier")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKMedicationDoseEvent samples that match a medication's concept identifier.
        ///
        ///
        /// Parameter `medicationConceptIdentifier`: The identifier of the medication that a dose event was created for.
        #[unsafe(method(predicateForMedicationDoseEventWithMedicationConceptIdentifier:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForMedicationDoseEventWithMedicationConceptIdentifier(
            medication_concept_identifier: &HKHealthConceptIdentifier,
        ) -> Retained<NSPredicate>;

        #[cfg(feature = "HKHealthConceptIdentifier")]
        /// Creates a predicate for use with HKQuery subclasses.
        ///
        /// Creates a query predicate that matches HKMedicationDoseEvent samples generated by any medication in a set of medication concept identifiers.
        ///
        ///
        /// Parameter `medicationConceptIdentifiers`: Any identifier of a medication that a dose event was created for.
        #[unsafe(method(predicateForMedicationDoseEventWithMedicationConceptIdentifiers:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForMedicationDoseEventWithMedicationConceptIdentifiers(
            medication_concept_identifiers: &NSSet<HKHealthConceptIdentifier>,
        ) -> Retained<NSPredicate>;
    );
}

/// HKUserAnnotatedMedications.
impl HKQuery {
    extern_methods!(
        /// Creates a predicate for use with HKUserAnnotatedMedicationQuery.
        ///
        /// Creates a query predicate that matches HKUserAnnotatedMedication objects that have the archived status specified.
        ///
        ///
        /// Parameter `isArchived`: The archived status of the medication. Ex: True will match medications in the archived section in the Health App.
        #[unsafe(method(predicateForUserAnnotatedMedicationsWithIsArchived:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForUserAnnotatedMedicationsWithIsArchived(
            is_archived: bool,
        ) -> Retained<NSPredicate>;

        /// Creates a predicate for use with HKUserAnnotatedMedicationQuery.
        ///
        /// Creates a query predicate that matches HKUserAnnotatedMedication objects that match the schedule status specified.
        ///
        ///
        /// Parameter `hasSchedule`: The schedule status of the medication. Ex: True will match medications that have a reminders schedule set up in the Health App.
        #[unsafe(method(predicateForUserAnnotatedMedicationsWithHasSchedule:))]
        #[unsafe(method_family = none)]
        pub unsafe fn predicateForUserAnnotatedMedicationsWithHasSchedule(
            has_schedule: bool,
        ) -> Retained<NSPredicate>;
    );
}