objc2_av_foundation/generated/

AVPlayerInterstitialEventController.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::*;
#[cfg(feature = "objc2-core-media")]
use objc2_core_media::*;
use objc2_foundation::*;

use crate::*;

/// These constants can be specified when creating AVPlayerInterstitialEvents in order to configure their behavior.
///
///
/// Indicates that the user may freely employ playback controls, as available, both within the primary content and in the interstitial content specified for the event.
///
/// Indicates that seeking within the primary content from a date prior to the date of the event to a date subsequent to the date of the event is not permitted.
///
/// Indicates that advancing the currentTime within an interstitial item, either by seeking ahead or by setting the playback rate to a value greater than the item's asset's preferredRate, is not permitted.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventrestrictions?language=objc)
// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct AVPlayerInterstitialEventRestrictions(pub NSUInteger);
bitflags::bitflags! {
    impl AVPlayerInterstitialEventRestrictions: NSUInteger {
        #[doc(alias = "AVPlayerInterstitialEventRestrictionNone")]
        const None = 0;
        #[doc(alias = "AVPlayerInterstitialEventRestrictionConstrainsSeekingForwardInPrimaryContent")]
        const ConstrainsSeekingForwardInPrimaryContent = 1<<0;
        #[doc(alias = "AVPlayerInterstitialEventRestrictionRequiresPlaybackAtPreferredRateForAdvancement")]
        const RequiresPlaybackAtPreferredRateForAdvancement = 1<<2;
        #[doc(alias = "AVPlayerInterstitialEventRestrictionDefaultPolicy")]
        const DefaultPolicy = AVPlayerInterstitialEventRestrictions::None.0;
    }
}

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

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

/// A particular cue can be specified when creating AVPlayerInterstitialEvents to override the start time/date to a predefined position.
///
///
/// No cue specified; event playback should start at event time (or date).
///
/// Event playback should occur before starting primary playback, regardless of initial primary playback position.
///
/// Event playback should occur after primary playback ends without error, either at the end of the primary asset or at the client-specified forward playback end time.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventcue?language=objc)
// NS_TYPED_ENUM
pub type AVPlayerInterstitialEventCue = NSString;

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventnocue?language=objc)
    pub static AVPlayerInterstitialEventNoCue: &'static AVPlayerInterstitialEventCue;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventjoincue?language=objc)
    pub static AVPlayerInterstitialEventJoinCue: &'static AVPlayerInterstitialEventCue;
}

extern "C" {
    /// [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventleavecue?language=objc)
    pub static AVPlayerInterstitialEventLeaveCue: &'static AVPlayerInterstitialEventCue;
}

/// These constants specify how an event occupies time on AVPlayerItemIntegratedTimeline.
///
///
/// Indicates this interstitial event occupies a single point on AVPlayerItemIntegratedTimeline.
///
/// Indicates this interstitial event fills AVPlayerItemIntegratedTimeline with the duration of this event.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventtimelineoccupancy?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct AVPlayerInterstitialEventTimelineOccupancy(pub NSInteger);
impl AVPlayerInterstitialEventTimelineOccupancy {
    #[doc(alias = "AVPlayerInterstitialEventTimelineOccupancySinglePoint")]
    pub const SinglePoint: Self = Self(0);
    #[doc(alias = "AVPlayerInterstitialEventTimelineOccupancyFill")]
    pub const Fill: Self = Self(1);
}

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

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

/// These constants describe the status of the asset list response for an AVPlayerInterstitialEvent.
///
///
/// Indicates that the asset list response is now available and non-nil, meaning the asset list read was successful.
///
/// Indicates that asset list response has been cleared and reverted to its original state of nil.
///
/// Indicates that the asset list response is unavailable, meaning the asset list read failed.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventassetlistresponsestatus?language=objc)
// NS_ENUM
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct AVPlayerInterstitialEventAssetListResponseStatus(pub NSInteger);
impl AVPlayerInterstitialEventAssetListResponseStatus {
    #[doc(alias = "AVPlayerInterstitialEventAssetListResponseStatusAvailable")]
    pub const Available: Self = Self(0);
    #[doc(alias = "AVPlayerInterstitialEventAssetListResponseStatusCleared")]
    pub const Cleared: Self = Self(1);
    #[doc(alias = "AVPlayerInterstitialEventAssetListResponseStatusUnavailable")]
    pub const Unavailable: Self = Self(2);
}

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

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

extern_class!(
    /// An AVPlayerInterstitialEvent provides instructions for temporarily suspending the playback of primary content in order to play alternative interstitial content instead, resuming playback of the primary content when playback of the interstitial content is complete or is canceled.
    ///
    ///
    /// The primary content is specified as an instance of AVPlayerItem, designated as the primary item of the interstitial event.
    ///
    /// The timing of interstitial playback is specified as a date within the date range of the primary item. Interstitial events are currently possible only for items with an intrinsic mapping from their timeline to real-time dates.
    ///
    /// The alternative interstitial content is specified as an array of one or more AVPlayerItems that will be used as templates for the creation of items for interstitial playback. In other words, these template items are not the actual items that will be played during interstitial playback; instead they are used to generate the items that are to be played, with property values that match the configuration of your template items.
    ///
    /// If you wish to observe the scheduling and progress of interstitial events, use an AVPlayerInterstitialEventMonitor. If you wish to specify your own schedule of interstitial events, use an AVPlayerInterstitialEventController.
    ///
    /// Note that while previously AVPlayerInterstitialEvent was an immutable object, it is now mutable. This allows it to be created and customized before being set on an AVPlayerInterstitialEventController.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialevent?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct AVPlayerInterstitialEvent;
);

unsafe impl NSCopying for AVPlayerInterstitialEvent {}

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

unsafe impl NSObjectProtocol for AVPlayerInterstitialEvent {}

impl AVPlayerInterstitialEvent {
    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(all(feature = "AVPlayerItem", feature = "objc2-core-media"))]
        /// Returns an instance of AVPlayerInterstitialEvent for use in scheduling interstitial playback.
        ///
        /// Parameter `primaryItem`: An AVPlayerItem representing the primary content during the playback of which the interstitial event should occur. The primaryItem must have an AVAsset that provides an intrinsic mapping from its timeline to real-time dates.
        ///
        /// Parameter `identifier`: An external identifier for the event.
        ///
        /// Parameter `time`: The time within the duration of the primary item at which playback of the primary content should be temporarily suspended and the interstitial items played.
        ///
        /// Parameter `templateItems`: An array of AVPlayerItems with configurations that will be reproduced for the playback of interstitial content. An NSInvalidArgumentException will be raised if any of the template items employs an AVAsset that lacks a URL, such as an AVComposition.
        ///
        /// Parameter `restrictions`: Indicates restrictions on the use of end user playback controls that are imposed by the event.
        ///
        /// Parameter `resumptionOffset`: Specifies the offset in time at which playback of the primary item should resume after interstitial playback has finished. Definite numeric values are supported. The value kCMTimeIndefinite can also be used, in order to specify that the effective resumption time offset should accord with the wallclock time elapsed during interstitial playback.
        ///
        /// Parameter `playoutLimit`: Specifies the offset from the beginning of the interstitial at which interstitial playback should end, if the interstitial asset(s) are longer. Pass a positive numeric value, or kCMTimeInvalid to indicate no playout limit.
        ///
        /// Parameter `userDefinedAttributes`: Storage for attributes defined by the client or the content vendor. Attribute names should begin with X- for uniformity with server insertion.
        ///
        /// Returns: An instance of AVPlayerInterstitialEvent.
        #[deprecated = "Use interstitialEventWithPrimaryItem:time: instead"]
        #[unsafe(method(interstitialEventWithPrimaryItem:identifier:time:templateItems:restrictions:resumptionOffset:playoutLimit:userDefinedAttributes:))]
        #[unsafe(method_family = none)]
        pub unsafe fn interstitialEventWithPrimaryItem_identifier_time_templateItems_restrictions_resumptionOffset_playoutLimit_userDefinedAttributes(
            primary_item: &AVPlayerItem,
            identifier: Option<&NSString>,
            time: CMTime,
            template_items: &NSArray<AVPlayerItem>,
            restrictions: AVPlayerInterstitialEventRestrictions,
            resumption_offset: CMTime,
            playout_limit: CMTime,
            user_defined_attributes: Option<&NSDictionary>,
        ) -> Retained<Self>;

        #[cfg(all(feature = "AVPlayerItem", feature = "objc2-core-media"))]
        /// Returns an instance of AVPlayerInterstitialEvent for use in scheduling interstitial playback.
        ///
        /// Parameter `primaryItem`: An AVPlayerItem representing the primary content during the playback of which the interstitial event should occur. The primaryItem must have an AVAsset that provides an intrinsic mapping from its timeline to real-time dates.
        ///
        /// Parameter `identifier`: An external identifier for the event.
        ///
        /// Parameter `date`: The date within the date range of the primary item at which playback of the primary content should be temporarily suspended and the interstitial items played.
        ///
        /// Parameter `templateItems`: An array of AVPlayerItems with configurations that will be reproduced for the playback of interstitial content. An NSInvalidArgumentException will be raised if any of the template items employs an AVAsset that lacks a URL, such as an AVComposition.
        ///
        /// Parameter `restrictions`: Indicates restrictions on the use of end user playback controls that are imposed by the event.
        ///
        /// Parameter `resumptionOffset`: Specifies the offset in time at which playback of the primary item should resume after interstitial playback has finished. Definite numeric values are supported. The value kCMTimeIndefinite can also be used, in order to specify that the effective resumption time offset should accord with the wallclock time elapsed during interstitial playback.
        ///
        /// Parameter `playoutLimit`: Specifies the offset from the beginning of the interstitial at which interstitial playback should end, if the interstitial asset(s) are longer. Pass a positive numeric value, or kCMTimeInvalid to indicate no playout limit.
        ///
        /// Parameter `userDefinedAttributes`: Storage for attributes defined by the client or the content vendor. Attribute names should begin with X- for uniformity with server insertion.
        ///
        /// Returns: An instance of AVPlayerInterstitialEvent.
        #[deprecated = "Use interstitialEventWithPrimaryItem:date: instead"]
        #[unsafe(method(interstitialEventWithPrimaryItem:identifier:date:templateItems:restrictions:resumptionOffset:playoutLimit:userDefinedAttributes:))]
        #[unsafe(method_family = none)]
        pub unsafe fn interstitialEventWithPrimaryItem_identifier_date_templateItems_restrictions_resumptionOffset_playoutLimit_userDefinedAttributes(
            primary_item: &AVPlayerItem,
            identifier: Option<&NSString>,
            date: &NSDate,
            template_items: &NSArray<AVPlayerItem>,
            restrictions: AVPlayerInterstitialEventRestrictions,
            resumption_offset: CMTime,
            playout_limit: CMTime,
            user_defined_attributes: Option<&NSDictionary>,
        ) -> Retained<Self>;

        #[cfg(all(feature = "AVPlayerItem", feature = "objc2-core-media"))]
        /// Returns an instance of AVPlayerInterstitialEvent for use in scheduling interstitial playback.
        ///
        /// Parameter `primaryItem`: An AVPlayerItem representing the primary content during the playback of which the interstitial event should occur. The primaryItem must have an AVAsset that provides an intrinsic mapping from its timeline to real-time dates.
        ///
        /// Parameter `time`: The time within the duration of the primary item at which playback of the primary content should be temporarily suspended and the interstitial items played.
        ///
        /// Returns: An instance of AVPlayerInterstitialEvent.
        #[unsafe(method(interstitialEventWithPrimaryItem:time:))]
        #[unsafe(method_family = none)]
        pub unsafe fn interstitialEventWithPrimaryItem_time(
            primary_item: &AVPlayerItem,
            time: CMTime,
        ) -> Retained<Self>;

        #[cfg(feature = "AVPlayerItem")]
        /// Returns an instance of AVPlayerInterstitialEvent for use in scheduling interstitial playback.
        ///
        /// Parameter `primaryItem`: An AVPlayerItem representing the primary content during the playback of which the interstitial event should occur. The primaryItem must have an AVAsset that provides an intrinsic mapping from its timeline to real-time dates.
        ///
        /// Parameter `date`: The date within the date range of the primary item at which playback of the primary content should be temporarily suspended and the interstitial items played.
        ///
        /// Returns: An instance of AVPlayerInterstitialEvent.
        #[unsafe(method(interstitialEventWithPrimaryItem:date:))]
        #[unsafe(method_family = none)]
        pub unsafe fn interstitialEventWithPrimaryItem_date(
            primary_item: &AVPlayerItem,
            date: &NSDate,
        ) -> Retained<Self>;

        #[cfg(feature = "AVPlayerItem")]
        /// An AVPlayerItem representing the primary content during the playback of which the interstitial event should occur. The primaryItem must have an AVAsset that provides an intrinsic mapping from its timeline to real-time dates.
        #[unsafe(method(primaryItem))]
        #[unsafe(method_family = none)]
        pub unsafe fn primaryItem(&self, mtm: MainThreadMarker) -> Option<Retained<AVPlayerItem>>;

        /// An external identifier for the event.
        ///
        /// If an event is set on an AVPlayerInterstitialEventController that already has an event with the same identifier, the old event will be replaced by the new one.
        #[unsafe(method(identifier))]
        #[unsafe(method_family = none)]
        pub unsafe fn identifier(&self) -> Retained<NSString>;

        #[cfg(feature = "objc2-core-media")]
        /// The time within the duration of the primary item at which playback of the primary content should be temporarily suspended and the interstitial items played.
        ///
        /// Will have a value equal to kCMTimeInvalid if the event was initialized with a date instead of a time.
        #[unsafe(method(time))]
        #[unsafe(method_family = none)]
        pub unsafe fn time(&self) -> CMTime;

        /// The date within the date range of the primary item at which playback of the primary content should be temporarily suspended and the interstitial items played.
        ///
        /// Will have a value of nil if the event was initialized with a time instead of a date.
        #[unsafe(method(date))]
        #[unsafe(method_family = none)]
        pub unsafe fn date(&self) -> Option<Retained<NSDate>>;

        #[cfg(feature = "AVPlayerItem")]
        /// An array of AVPlayerItems with configurations that will be reproduced for the playback of interstitial content.
        ///
        /// If you want the instances of AVURLAsset used during interstitial playback to be identical to the ones you specify for templateItems in AVPlayerInterstitialEvents that you set on an AVPlayerInterstitialEventController, rather than equivalent AVURLAssets with the same URL, you must create them with a value for the key AVURLAssetPrimarySessionIdentifierKey that's equal to the httpSessionIdentifier of the primary AVPlayerItem's asset. See AVAsset.h. This is especially useful if you require the use of a custom AVAssetResourceLoader delegate for interstitial assets.
        ///
        /// An NSInvalidArgumentException will be raised if any of the template items employs an AVAsset that lacks a URL, such as an AVComposition.
        #[unsafe(method(templateItems))]
        #[unsafe(method_family = none)]
        pub unsafe fn templateItems(
            &self,
            mtm: MainThreadMarker,
        ) -> Retained<NSArray<AVPlayerItem>>;

        /// Indicates restrictions on the use of end user playback controls that are imposed by the event.
        #[unsafe(method(restrictions))]
        #[unsafe(method_family = none)]
        pub unsafe fn restrictions(&self) -> AVPlayerInterstitialEventRestrictions;

        #[cfg(feature = "objc2-core-media")]
        /// Specifies the offset in time at which playback of the primary item should resume after interstitial playback has finished.
        ///
        /// Definite numeric values are supported. The value kCMTimeIndefinite can also be used, in order to specify that the effective resumption time offset should accord with the wallclock time elapsed during interstitial playback; this value is typically suitable for live broadcasts. The default value is kCMTimeZero.
        #[unsafe(method(resumptionOffset))]
        #[unsafe(method_family = none)]
        pub unsafe fn resumptionOffset(&self) -> CMTime;

        #[cfg(feature = "objc2-core-media")]
        /// Specifies the offset in time at which playback of the interstitial event should end.
        ///
        /// Can be any positive numeric value, or invalid. The default value is kCMTimeInvalid, which means there is no limit.
        #[unsafe(method(playoutLimit))]
        #[unsafe(method_family = none)]
        pub unsafe fn playoutLimit(&self) -> CMTime;

        /// Specifies that the start time of interstitial playback should be snapped to a segment boundary of the primary asset
        ///
        /// If true, the start time or date of the interstitial will be adjusted to the nearest segment boundary when the primary player is playing an HTTP Live Streaming asset.
        #[unsafe(method(alignsStartWithPrimarySegmentBoundary))]
        #[unsafe(method_family = none)]
        pub unsafe fn alignsStartWithPrimarySegmentBoundary(&self) -> bool;

        /// Specifies that the resumption time of primary playback should be snapped to a segment boundary of the primary asset
        ///
        /// If true, the resumption time of primary playback following an interstitial will be adjusted to the nearest segment boundary when the primary player is playing an HTTP Live Streaming asset.
        #[unsafe(method(alignsResumptionWithPrimarySegmentBoundary))]
        #[unsafe(method_family = none)]
        pub unsafe fn alignsResumptionWithPrimarySegmentBoundary(&self) -> bool;

        /// The cue property is used to schedule event playback at a predefined position of primary playback.
        #[unsafe(method(cue))]
        #[unsafe(method_family = none)]
        pub unsafe fn cue(&self) -> Retained<AVPlayerInterstitialEventCue>;

        /// Specifies that the interstitial should be scheduled for playback once only, and suppressed for subsequent replay.
        ///
        /// The "once" provision takes effect at the start of interstitial playback. The interstitial will not be scheduled again even if the first playback is canceled before completion.
        #[unsafe(method(willPlayOnce))]
        #[unsafe(method_family = none)]
        pub unsafe fn willPlayOnce(&self) -> bool;

        /// Attributes of the event defined by the content vendor or the client.
        ///
        /// Dictionary keys are attribute names. Dictionary values are attribute values.
        #[unsafe(method(userDefinedAttributes))]
        #[unsafe(method_family = none)]
        pub unsafe fn userDefinedAttributes(&self) -> Retained<NSDictionary>;

        /// The asset list JSON response as a dictionary, or nil if no asset list response has been loaded for the event.
        ///
        /// If the AVPlayerInterstitialEvent's templateItems is empty and the assetListResponse is nil, then an asset list read is expected. If the AVPlayerInterstitialEvent's templateItems is not empty and the assetListResponse is nil, then an asset list read is not expected.
        #[unsafe(method(assetListResponse))]
        #[unsafe(method_family = none)]
        pub unsafe fn assetListResponse(&self) -> Option<Retained<NSDictionary>>;

        /// Indicates this event's occupancy on AVPlayerItemIntegratedTimeline. The default value is AVPlayerInterstitialEventTimelineSinglePointOccupancy.
        #[unsafe(method(timelineOccupancy))]
        #[unsafe(method_family = none)]
        pub unsafe fn timelineOccupancy(&self) -> AVPlayerInterstitialEventTimelineOccupancy;

        /// Indicates this event will supplement the primary content and should be presented unified with the primary item. The default value is NO.
        #[unsafe(method(supplementsPrimaryContent))]
        #[unsafe(method_family = none)]
        pub unsafe fn supplementsPrimaryContent(&self) -> bool;

        /// Indicates this event's content is dynamic and server may respond with different interstitial assets for other particpants in coordinated playback.
        ///
        /// Indicates this event's content is dynamic and server may respond with different interstitial assets for other particpants in coordinated playback. If this value is set to NO and the primary asset is particpating in coordinated playback, this event will participate in coordinated playback as well. The default value is YES.
        #[unsafe(method(contentMayVary))]
        #[unsafe(method_family = none)]
        pub unsafe fn contentMayVary(&self) -> bool;
    );
}

extern_class!(
    /// An AVPlayerInterstitialEventMonitor allows you to observe the scheduling and progress of interstitial events, specified either intrinsically within the content of primary items, such as via use of directives carried by HLS media playlists, or via use of an AVPlayerInterstitialEventController.
    ///
    ///
    /// The schedule of interstitial events is provided as an array of AVPlayerInterstitialEvents. For each AVPlayerInterstitialEvent, when the primary player's current item is the primary item of the interstitial event and its currentDate reaches the date of the event, playback of the primary item by the primary player is temporarily suspended, i.e. its timeControlStatus changes to AVPlayerTimeControlStatusWaitingToPlayAtSpecifiedRate and its reasonForWaitingToPlay will change to AVPlayerWaitingDuringInterstitialEventReason. During this suspension, playback of items that replicate the interstitial template items of the event are played by the interstitial player, which temporarily assumes the output configuration of the primary player; for example, its visual content will be routed to AVPlayerLayers that reference the primary player. Once the interstitial player has advanced through playback of the interstitial items specified by the event or its current item otherwise becomes nil, playback of the primary content will resume, at an offset from the time at which it was suspended as specified by the event.
    ///
    /// Subclasses of this type that are used from Swift must fulfill the requirements of a Sendable type.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventmonitor?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct AVPlayerInterstitialEventMonitor;
);

unsafe impl Send for AVPlayerInterstitialEventMonitor {}

unsafe impl Sync for AVPlayerInterstitialEventMonitor {}

unsafe impl NSObjectProtocol for AVPlayerInterstitialEventMonitor {}

impl AVPlayerInterstitialEventMonitor {
    extern_methods!(
        #[cfg(feature = "AVPlayer")]
        /// Returns an instance of AVPlayerInterstitialEvent for use in observing and scheduling interstitial playback.
        ///
        /// Parameter `primaryPlayer`: The AVPlayer that will play the primaryItems of the receiver's interstitial events.
        ///
        /// Returns: An instance of AVPlayerInterstitialEventMonitor.
        #[unsafe(method(interstitialEventMonitorWithPrimaryPlayer:))]
        #[unsafe(method_family = none)]
        pub unsafe fn interstitialEventMonitorWithPrimaryPlayer(
            primary_player: &AVPlayer,
        ) -> Retained<Self>;

        #[cfg(feature = "AVPlayer")]
        #[unsafe(method(initWithPrimaryPlayer:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithPrimaryPlayer(
            this: Allocated<Self>,
            primary_player: &AVPlayer,
        ) -> Retained<Self>;

        #[cfg(feature = "AVPlayer")]
        /// The AVPlayer that will play the primaryItems of the receiver's interstitial events.
        #[unsafe(method(primaryPlayer))]
        #[unsafe(method_family = none)]
        pub unsafe fn primaryPlayer(&self, mtm: MainThreadMarker) -> Option<Retained<AVPlayer>>;

        #[cfg(feature = "AVPlayer")]
        /// The AVQueuePlayer that will play interstitial items during suspension of playback of primary items.
        #[unsafe(method(interstitialPlayer))]
        #[unsafe(method_family = none)]
        pub unsafe fn interstitialPlayer(&self, mtm: MainThreadMarker) -> Retained<AVQueuePlayer>;

        /// Provides the current schedule of interstitial events, specified either intrinsically within the content of primary items, such as via use of directives carried by HLS media playlists, or via use of an AVPlayerInterstitialEventController.
        ///
        /// When interstitial events follow a schedule specified intrinsically within the content of primary items, the value of this property will typically change whenever the currentItem of the primaryPlayer changes. For HLS content that specifies interstitials via the use of DATERANGE tags, the value of this property may also change whenever the set of DATERANGE tags in the currentItem's media playlist changes.
        /// When interstitial events follow a schedule specified via use of an AVPlayerInterstitialEventController, the value of this property changes only when a new schedule is set on the AVPlayerInterstitialEventController.
        /// The events returned in this array are immutable. Attempting to mutate them will trigger an exception. To alter an event, make a copy and mutate the copy.
        #[unsafe(method(events))]
        #[unsafe(method_family = none)]
        pub unsafe fn events(&self) -> Retained<NSArray<AVPlayerInterstitialEvent>>;

        /// The current interstitial event. Has a value of nil during playback of primary content by the primary player.
        #[unsafe(method(currentEvent))]
        #[unsafe(method_family = none)]
        pub unsafe fn currentEvent(&self) -> Option<Retained<AVPlayerInterstitialEvent>>;
    );
}

/// Methods declared on superclass `NSObject`.
impl AVPlayerInterstitialEventMonitor {
    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 "C" {
    /// A notification that's posted whenever the value of events of an AVPlayerInterstitialEventMonitor is changed.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventmonitoreventsdidchangenotification?language=objc)
    pub static AVPlayerInterstitialEventMonitorEventsDidChangeNotification:
        &'static NSNotificationName;
}

extern "C" {
    /// A notification that's posted whenever the currentEvent of an AVPlayerInterstitialEventMonitor changes.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventmonitorcurrenteventdidchangenotification?language=objc)
    pub static AVPlayerInterstitialEventMonitorCurrentEventDidChangeNotification:
        &'static NSNotificationName;
}

extern "C" {
    /// A notification that is posted whenever an AVPlayerInterstitialEvent's asset list response status changes.
    ///
    /// Carries a userInfo dictionary that can contain the following keys and values:
    /// 1. AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeEventKey, with a value that indicates the AVPlayerInterstitialEvent for which the asset response status has changed.
    /// 2. AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeStatusKey, with a value of type AVPlayerInterstitialEventAssetListResponseStatus, indicating the changed asset response status.
    /// 3. AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeErrorKey, with a value of type NSError that carries additional information about the failure to read the asset list. This key is only present when the new AVPlayerInterstitialEventAssetListResponseStatus is AVPlayerInterstitialEventAssetListResponseStatusUnavailable.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventmonitorassetlistresponsestatusdidchangenotification?language=objc)
    pub static AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeNotification:
        &'static NSNotificationName;
}

extern "C" {
    /// The dictionary key for the AVPlayerInterstitial event that had its asset list response status changed in the payload of the AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeNotification.
    ///
    /// The value corresponding to this key is of type AVPlayerInterstitialEvent.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventmonitorassetlistresponsestatusdidchangeeventkey?language=objc)
    pub static AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeEventKey:
        &'static NSString;
}

extern "C" {
    /// The dictionary key for the asset list response status in the payload of the AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeNotification.
    ///
    /// The value corresponding to this key is of type AVPlayerInterstitialEventAssetListResponseStatus.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventmonitorassetlistresponsestatusdidchangestatuskey?language=objc)
    pub static AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeStatusKey:
        &'static NSString;
}

extern "C" {
    /// The dictionary key for the NSError in the payload of the AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeNotification.
    ///
    /// The value corresponding to this key is of type NSError. This key only exists in the payload of AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeNotification if AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeStatusKey in the same payload points to a value of AVPlayerInterstitialEventAssetListResponseStatusUnavailable.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventmonitorassetlistresponsestatusdidchangeerrorkey?language=objc)
    pub static AVPlayerInterstitialEventMonitorAssetListResponseStatusDidChangeErrorKey:
        &'static NSString;
}

extern_class!(
    /// An AVPlayerInterstitialEventController allows you to specify a schedule of interstitial events for items played by a primary player.
    /// By creating an instance of AVPlayerInterstitialEventController and setting a schedule of interstitial events, you pre-empt directives the are intrinsic to the items played by the primary player, if any exist, causing them to be ignored.
    ///
    ///
    /// The schedule of interstitial events is specified as an array of AVPlayerInterstitialEvents. For each AVPlayerInterstitialEvent, when the primary player's current item is the primary item of the interstitial event and its currentDate reaches the date of the event, playback of the primary item by the primary player is temporarily suspended, i.e. its timeControlStatus changes to AVPlayerTimeControlStatusWaitingToPlayAtSpecifiedRate and its reasonForWaitingToPlay will change to AVPlayerWaitingDuringInterstitialEventReason. During this suspension, playback of items that replicate the interstitial template items of the event are played by the interstitial player, which temporarily assumes the output configuration of the primary player; for example, its visual content will be routed to AVPlayerLayers that reference the primary player. Once the interstitial player has advanced through playback of the interstitial items specified by the event or its current item otherwise becomes nil, playback of the primary content will resume, at an offset from the time at which it was suspended as specified by the event.
    ///
    /// Subclasses of this type that are used from Swift must fulfill the requirements of a Sendable type.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerinterstitialeventcontroller?language=objc)
    #[unsafe(super(AVPlayerInterstitialEventMonitor, NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct AVPlayerInterstitialEventController;
);

unsafe impl NSObjectProtocol for AVPlayerInterstitialEventController {}

impl AVPlayerInterstitialEventController {
    extern_methods!(
        #[cfg(feature = "AVPlayer")]
        /// Returns an instance of AVPlayerInterstitialEvent for use in observing and scheduling interstitial playback.
        ///
        /// Parameter `primaryPlayer`: The AVPlayer that will play the primaryItems of the receiver's interstitial events.
        ///
        /// Returns: An instance of AVPlayerInterstitialEventController.
        ///
        /// This method throws an exception if the primary player is an interstitial player.
        #[unsafe(method(interstitialEventControllerWithPrimaryPlayer:))]
        #[unsafe(method_family = none)]
        pub unsafe fn interstitialEventControllerWithPrimaryPlayer(
            primary_player: &AVPlayer,
        ) -> Retained<Self>;

        #[cfg(feature = "AVPlayer")]
        /// This method throws an exception if the primary player is an interstitial player.
        #[unsafe(method(initWithPrimaryPlayer:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithPrimaryPlayer(
            this: Allocated<Self>,
            primary_player: &AVPlayer,
        ) -> Retained<Self>;

        /// Specifies the current schedule of interstitial events.
        ///
        /// Setting this property to a non-nil value cancels and overrides all previously scheduled future interstitial events, including those that are intrinsically specified by the content of primary items, such as directives carried by HLS media playlists. Setting it to nil causes its value to be reset in accordance with the content of the current primary item.
        ///
        /// If you change the value of events during an interstitial event and the current event is not included in the new value of events, the current event is nevertheless allowed to continue until completion. If you wish to cancel the current event, use -cancelCurrentEventWithResumptionOffset:.
        ///
        /// If interstitial events are scheduled with dates that coincide either with the date of another scheduled interstitial event or with the date range of the primary content that's omitted according to the resumption offset of another scheduled interstitial event, the primary content will remain suspended until all coinciding interstitial events have been completed. The effective resumption offset will be the sum of the resumption offsets of the coinciding interstitial events. (Note that the sum of a numeric CMTime and kCMTimeIndefinite is kCMTimeIndefinite.)
        ///
        /// If interstitial events are scheduled for the same date, they are ordered according to their position in the events array.
        ///
        /// The receiver will make a copy of the events that are set on it. Subsequent mutations on the original events will have no effect on the copy.
        ///
        /// An NSInvalidArgumentException will be raised if an under-specified AVPlayerInterstitialEvent is set, such as one with a nil primaryItem, or with neither a time nor a date.
        #[unsafe(method(events))]
        #[unsafe(method_family = none)]
        pub unsafe fn events(&self) -> Retained<NSArray<AVPlayerInterstitialEvent>>;

        /// Setter for [`events`][Self::events].
        #[unsafe(method(setEvents:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setEvents(&self, events: Option<&NSArray<AVPlayerInterstitialEvent>>);

        #[cfg(feature = "objc2-core-media")]
        /// Causes the playback of any and all interstitial content currently in progress to be abandoned and the playback of primary content to be resumed.
        ///
        /// Parameter `resumptionOffset`: Specifies the offset in time at which playback of the primary player's current item should resume after interstitial playback has finished. To specify that the effective resumption time offset should accord with the wallclock time elapsed during interstitial playback, pass a value of kCMTimeIndefinite.
        ///
        /// If invoked during the handling of coinciding interstitial events, they will all be canceled.
        /// When you cancel interstitial events via the use of this method, the value of resumptionOffset that you pass overrides the events' resumptionOffset.
        /// Has no effect while currentEvent is nil.
        #[unsafe(method(cancelCurrentEventWithResumptionOffset:))]
        #[unsafe(method_family = none)]
        pub unsafe fn cancelCurrentEventWithResumptionOffset(&self, resumption_offset: CMTime);
    );
}

/// Methods declared on superclass `AVPlayerInterstitialEventMonitor`.
impl AVPlayerInterstitialEventController {
    extern_methods!(
        #[cfg(feature = "AVPlayer")]
        /// Returns an instance of AVPlayerInterstitialEvent for use in observing and scheduling interstitial playback.
        ///
        /// Parameter `primaryPlayer`: The AVPlayer that will play the primaryItems of the receiver's interstitial events.
        ///
        /// Returns: An instance of AVPlayerInterstitialEventMonitor.
        #[unsafe(method(interstitialEventMonitorWithPrimaryPlayer:))]
        #[unsafe(method_family = none)]
        pub unsafe fn interstitialEventMonitorWithPrimaryPlayer(
            primary_player: &AVPlayer,
        ) -> Retained<Self>;
    );
}

/// Methods declared on superclass `NSObject`.
impl AVPlayerInterstitialEventController {
    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 "C" {
    /// Indicates that the player is waiting for the completion of an interstitial event.
    ///
    /// The player is waiting for playback because an interstitial event is currently in progress. Interstitial events can be monitored via use of an AVPlayerInterstitialEventMonitor.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/avfoundation/avplayerwaitingduringinterstitialeventreason?language=objc)
    #[cfg(feature = "AVPlayer")]
    pub static AVPlayerWaitingDuringInterstitialEventReason: &'static AVPlayerWaitingReason;
}

/// AVPlayerInterstitialSupport.
#[cfg(feature = "AVPlayer")]
impl AVPlayer {
    extern_methods!();
}

/// AVPlayerInterstitialSupport.
#[cfg(feature = "AVPlayerItem")]
impl AVPlayerItem {
    extern_methods!(
        /// Allows interstitials to be played according to a schedule that's specified by server-side directives. The default value is YES. A value of NO prevents automatic scheduling of future server-side interstitial events. Events specified by an AVPlayerInterstitialEventController override server-side events, regardless of the value of this property.
        ///
        /// Before macOS 13, iOS 16, tvOS 16, and watchOS 9, this property must be accessed on the main thread/queue.
        #[unsafe(method(automaticallyHandlesInterstitialEvents))]
        #[unsafe(method_family = none)]
        pub unsafe fn automaticallyHandlesInterstitialEvents(&self) -> bool;

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

        /// If the item was created automatically according to a template item for looping, for interstitial playback, or for other purposes, indicates the AVPlayerItem that was used as the template.
        #[unsafe(method(templatePlayerItem))]
        #[unsafe(method_family = none)]
        pub unsafe fn templatePlayerItem(&self) -> Option<Retained<AVPlayerItem>>;
    );
}